c6a98d4f2adbccfddbc255f3ffb943b5ff4377ea
[openafs.git] / src / WINNT / afsd / cm_dnlc.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 /*
11 **      This implements the directory to name cache lookup. 
12 **      Given a directory scache and a name, the dnlc returns the
13 **      vcache corresponding to the name. The vcache entries that 
14 **      exist in the dnlc are not refcounted. 
15 **
16 */
17
18 #include <afs/param.h>
19 #include <afs/stds.h>
20
21 #include <windows.h>
22 #include <winsock2.h>
23 #include <string.h>
24 #include <stdlib.h>
25 #include <osi.h>
26 #include "afsd.h"
27
28 osi_rwlock_t cm_dnlcLock;
29
30 static cm_dnlcstats_t dnlcstats;        /* dnlc statistics */
31 static int cm_useDnlc = 1;      /* yes, start using the dnlc */
32 static int cm_debugDnlc = 0;    /* debug dnlc */
33
34
35 /* Hash table invariants:
36  *     1.  If nameHash[i] is NULL, list is empty
37  *     2.  A single element in a hash bucket has itself as prev and next.
38  */
39
40 /* Must be called with cm_dnlcLock write locked */
41 static cm_nc_t * 
42 GetMeAnEntry() 
43 {
44     static unsigned int nameptr = 0; /* next bucket to pull something from */
45     cm_nc_t *tnc;
46     int j;
47   
48     if (cm_data.ncfreelist) 
49     {
50         tnc = cm_data.ncfreelist;
51         cm_data.ncfreelist = tnc->next;
52         return tnc;
53     }
54
55     for (j=0; j<NHSIZE+2; j++, nameptr++) 
56     {
57         if (nameptr >= NHSIZE) 
58             nameptr =0;
59         if (cm_data.nameHash[nameptr])
60             break;
61     }
62
63     tnc = cm_data.nameHash[nameptr];
64     if (!tnc)   
65     {
66         osi_Log0(afsd_logp,"null tnc in GetMeAnEntry");
67         return 0;
68     }
69
70     if (tnc->prev == tnc) 
71     {                   /* only thing in list, don't screw around */
72         cm_data.nameHash[nameptr] = (cm_nc_t *) 0;
73         return (tnc);
74     }
75
76     tnc = tnc->prev;            /* grab oldest one in this bucket */
77     tnc->next->prev = tnc->prev;/* remove it from list */
78     tnc->prev->next = tnc->next;
79
80     return (tnc);
81 }
82
83 static void 
84 InsertEntry(cm_nc_t *tnc)
85 {
86     unsigned int key; 
87     key = tnc->key & (NHSIZE -1);
88
89     if (!cm_data.nameHash[key]) 
90     {
91         cm_data.nameHash[key] = tnc;
92         tnc->next = tnc->prev = tnc;
93     }
94     else 
95     {
96         tnc->next = cm_data.nameHash[key];
97         tnc->prev = tnc->next->prev;
98         tnc->next->prev = tnc;
99         tnc->prev->next = tnc;
100         cm_data.nameHash[key] = tnc;
101     }
102 }
103
104
105 void 
106 cm_dnlcEnter ( cm_scache_t *adp,
107                char        *aname,
108                cm_scache_t *avc )
109 {
110     cm_nc_t *tnc;
111     unsigned int key, skey, new=0;
112     char *ts = aname;
113     int safety;
114
115     if (!cm_useDnlc)
116         return ;
117
118     if (!strcmp(aname,".") || !strcmp(aname,".."))
119         return ;
120
121     if ( cm_debugDnlc ) 
122         osi_Log3(afsd_logp,"cm_dnlcEnter dir %x name %s scache %x", 
123             adp, osi_LogSaveString(afsd_logp,aname), avc);
124
125     dnlcHash( ts, key );  /* leaves ts pointing at the NULL */
126     if (ts - aname >= CM_AFSNCNAMESIZE) 
127         return ;
128     skey = key & (NHSIZE -1);
129
130     lock_ObtainWrite(&cm_dnlcLock);
131     dnlcstats.enters++;
132   
133     for (tnc = cm_data.nameHash[skey], safety=0; tnc; tnc = tnc->next, safety++ )
134         if ((tnc->dirp == adp) && (!strcmp(tnc->name, aname)))
135             break;                              /* preexisting entry */
136         else if ( tnc->next == cm_data.nameHash[skey])  /* end of list */
137         {
138             tnc = NULL;
139             break;
140         }
141         else if (safety > NCSIZE) 
142         {
143             dnlcstats.cycles++;
144             lock_ReleaseWrite(&cm_dnlcLock);
145
146             if ( cm_debugDnlc )
147                 osi_Log0(afsd_logp, "DNLC cycle");
148             cm_dnlcPurge();
149             return;
150         }
151         
152     if ( !tnc )
153     {
154         new = 1;        /* entry does not exist, we are creating a new entry*/
155         tnc = GetMeAnEntry();
156     }
157     if ( tnc )
158     { 
159         tnc->dirp = adp;
160         tnc->vp = avc;
161         tnc->key = key;
162         memcpy (tnc->name, aname, ts-aname+1); /* include the NULL */
163
164         if ( new )      /* insert entry only if it is newly created */ 
165                 InsertEntry(tnc);
166
167     }
168     lock_ReleaseWrite(&cm_dnlcLock);
169
170     if ( !tnc)
171         cm_dnlcPurge();
172 }
173
174 /*
175 * if the scache entry is found, return it held
176 */
177 cm_scache_t *
178 cm_dnlcLookup (cm_scache_t *adp, cm_lookupSearch_t* sp)
179 {
180     cm_scache_t * tvc;
181     unsigned int key, skey;
182     char* aname = sp->searchNamep;
183     char *ts = aname;
184     cm_nc_t * tnc, * tnc_begin;
185     int safety, match;
186   
187     if (!cm_useDnlc)
188         return NULL;
189     if ( cm_debugDnlc ) 
190         osi_Log2(afsd_logp, "cm_dnlcLookup dir %x name %s", 
191                 adp, osi_LogSaveString(afsd_logp,aname));
192
193     dnlcHash( ts, key );  /* leaves ts pointing at the NULL */
194     if (ts - aname >= CM_AFSNCNAMESIZE) 
195         return NULL;
196
197     skey = key & (NHSIZE -1);
198
199     lock_ObtainRead(&cm_dnlcLock);
200     dnlcstats.lookups++;             /* Is a dnlcread lock sufficient? */
201
202     ts = 0;
203     tnc_begin = cm_data.nameHash[skey];
204     for ( tvc = (cm_scache_t *) NULL, tnc = tnc_begin, safety=0; 
205           tnc; tnc = tnc->next, safety++ ) 
206     {
207         if (tnc->dirp == adp) 
208         {
209         if( cm_debugDnlc ) 
210             osi_Log1(afsd_logp,"Looking at [%s]",
211                      osi_LogSaveString(afsd_logp,tnc->name));
212
213             if ( sp->caseFold )         /* case insensitive */
214             {
215             match = cm_stricmp(tnc->name, aname);
216             if ( !match )       /* something matches */
217             {
218                 tvc = tnc->vp;
219                 ts = tnc->name;
220
221                 /* determine what type of match it is */
222                 if ( !strcmp(tnc->name, aname))
223                 {       
224                     /* exact match. */
225                     sp->ExactFound = 1;
226
227                     if( cm_debugDnlc )
228                         osi_Log1(afsd_logp,"DNLC found exact match [%s]",
229                                  osi_LogSaveString(afsd_logp,tnc->name));
230                     break;
231                 }
232                 else if ( cm_NoneUpper(tnc->name))
233                     sp->LCfound = 1;
234                 else if ( cm_NoneLower(tnc->name))
235                     sp->UCfound = 1;
236                 else    
237                     sp->NCfound = 1;
238                 /* Don't break here. We might find an exact match yet */
239             }
240             }
241             else                        /* case sensitive */
242             {
243             match = strcmp(tnc->name, aname);
244             if ( !match ) /* found a match */
245             {
246                 sp->ExactFound = 1;
247                 tvc = tnc->vp; 
248                 ts = tnc->name;
249                 break;
250             }
251             }
252         }
253         if (tnc->next == cm_data.nameHash[skey]) 
254     {                   /* end of list */
255             break;
256         }
257         else if (tnc->next == tnc_begin || safety > NCSIZE) 
258         {
259             dnlcstats.cycles++;
260             lock_ReleaseRead(&cm_dnlcLock);
261
262             if ( cm_debugDnlc ) 
263                 osi_Log0(afsd_logp, "DNLC cycle"); 
264             cm_dnlcPurge();
265             return(NULL);
266         }
267     }
268
269     if(cm_debugDnlc && ts) {
270         osi_Log3(afsd_logp, "DNLC matched [%s] for [%s] with vnode[%ld]",
271                  osi_LogSaveString(afsd_logp,ts),
272                  osi_LogSaveString(afsd_logp,aname),
273                  (long) tvc->fid.vnode);
274     }
275
276     if (!tvc) 
277         dnlcstats.misses++;     /* Is a dnlcread lock sufficient? */
278     else 
279     {
280         sp->found = 1;
281         sp->fid.vnode  = tvc->fid.vnode; 
282         sp->fid.unique = tvc->fid.unique;       
283     }
284     lock_ReleaseRead(&cm_dnlcLock);
285
286     if (tvc)
287         cm_HoldSCache(tvc);
288
289     if ( cm_debugDnlc && tvc ) 
290         osi_Log1(afsd_logp, "cm_dnlcLookup found %x", tvc);
291     
292     return tvc;
293 }
294
295
296 static int
297 RemoveEntry (cm_nc_t *tnc, unsigned int key)
298 {
299     if (!tnc->prev) /* things on freelist always have null prev ptrs */
300     {
301         osi_Log0(afsd_logp,"Bogus dnlc freelist");
302         return 1;   /* error */
303     }
304
305     if (tnc == tnc->next)  /* only one in list */
306         cm_data.nameHash[key] = (cm_nc_t *) 0;
307     else 
308     {
309         if (tnc == cm_data.nameHash[key])
310             cm_data.nameHash[key]  = tnc->next;
311         tnc->prev->next = tnc->next;
312         tnc->next->prev = tnc->prev;
313     }
314
315     memset(tnc, 0, sizeof(cm_nc_t));
316     tnc->magic = CM_DNLC_MAGIC;
317     return 0;     /* success */
318 }
319
320
321 void 
322 cm_dnlcRemove (cm_scache_t *adp, char *aname)
323 {
324     unsigned int key, skey, error=0;
325     int found= 0, safety;
326     char *ts = aname;
327     cm_nc_t *tnc, *tmp;
328   
329     if (!cm_useDnlc)
330         return ;
331
332     if ( cm_debugDnlc )
333         osi_Log2(afsd_logp, "cm_dnlcRemove dir %x name %s", 
334                 adp, osi_LogSaveString(afsd_logp,aname));
335
336     dnlcHash( ts, key );  /* leaves ts pointing at the NULL */
337     if (ts - aname >= CM_AFSNCNAMESIZE) 
338         return ;
339
340     skey = key & (NHSIZE -1);
341     lock_ObtainWrite(&cm_dnlcLock);
342     dnlcstats.removes++;
343
344     for (tnc = cm_data.nameHash[skey], safety=0; tnc; safety++) 
345     {
346         if ( (tnc->dirp == adp) && (tnc->key == key) 
347                         && !strcmp(tnc->name,aname) )
348         {
349             tmp = tnc->next;
350             error = RemoveEntry(tnc, skey);
351             if ( error )
352                 break;
353
354             tnc->next = cm_data.ncfreelist; /* insert entry into freelist */
355             cm_data.ncfreelist = tnc;
356             found = 1;          /* found at least one entry */
357
358             tnc = tmp;          /* continue down the linked list */
359         }
360         else if (tnc->next == cm_data.nameHash[skey]) /* end of list */
361             break;
362         else
363             tnc = tnc->next;
364         if ( safety > NCSIZE )
365         {
366             dnlcstats.cycles++;
367             lock_ReleaseWrite(&cm_dnlcLock);
368
369             if ( cm_debugDnlc ) 
370                 osi_Log0(afsd_logp, "DNLC cycle"); 
371             cm_dnlcPurge();
372             return;
373         }
374     }
375     lock_ReleaseWrite(&cm_dnlcLock);
376
377     if (!found && !error && cm_debugDnlc)
378         osi_Log0(afsd_logp, "cm_dnlcRemove name not found");
379
380     if ( error )
381         cm_dnlcPurge();
382 }
383
384 /* remove anything pertaining to this directory */
385 void 
386 cm_dnlcPurgedp (cm_scache_t *adp)
387 {
388     int i;
389     int err=0;
390
391     if (!cm_useDnlc)
392         return ;
393
394     if ( cm_debugDnlc )
395         osi_Log1(afsd_logp, "cm_dnlcPurgedp dir %x", adp);
396
397     lock_ObtainWrite(&cm_dnlcLock);
398     dnlcstats.purgeds++;
399
400     for (i=0; i<NCSIZE && !err; i++) 
401     {
402         if (cm_data.nameCache[i].dirp == adp ) 
403         {
404             if (cm_data.nameCache[i].prev) {
405                 err = RemoveEntry(&cm_data.nameCache[i], cm_data.nameCache[i].key & (NHSIZE-1));
406                 if (!err)
407                 {
408                     cm_data.nameCache[i].next = cm_data.ncfreelist;
409                     cm_data.ncfreelist = &cm_data.nameCache[i];
410                 }
411             } else {
412                 cm_data.nameCache[i].dirp = cm_data.nameCache[i].vp = (cm_scache_t *) 0;
413             }
414         }
415     }
416     lock_ReleaseWrite(&cm_dnlcLock);
417     if ( err )
418         cm_dnlcPurge();
419 }
420
421 /* remove anything pertaining to this file */
422 void 
423 cm_dnlcPurgevp (cm_scache_t *avc)
424 {
425     int i;
426     int err=0;
427
428     if (!cm_useDnlc)
429         return ;
430
431     if ( cm_debugDnlc )
432         osi_Log1(afsd_logp, "cm_dnlcPurgevp scache %x", avc);
433
434     lock_ObtainWrite(&cm_dnlcLock);
435     dnlcstats.purgevs++;
436
437     for (i=0; i<NCSIZE && !err ; i++) 
438     {
439         if (cm_data.nameCache[i].vp == avc) 
440         {
441             if (cm_data.nameCache[i].prev) {
442                 err = RemoveEntry(&cm_data.nameCache[i], cm_data.nameCache[i].key & (NHSIZE-1));
443                 if (!err)
444                 {
445                     cm_data.nameCache[i].next = cm_data.ncfreelist;
446                     cm_data.ncfreelist = &cm_data.nameCache[i];
447                 }
448             } else {
449                 cm_data.nameCache[i].dirp = cm_data.nameCache[i].vp = (cm_scache_t *) 0;
450             }
451         }
452     }
453     lock_ReleaseWrite(&cm_dnlcLock);
454     if ( err )
455         cm_dnlcPurge();
456 }
457
458 /* remove everything */
459 void cm_dnlcPurge(void)
460 {
461     int i;
462
463     if (!cm_useDnlc)
464         return ;
465
466     if ( cm_debugDnlc )
467         osi_Log0(afsd_logp, "cm_dnlcPurge");
468
469     lock_ObtainWrite(&cm_dnlcLock);
470     dnlcstats.purges++;
471     
472     cm_data.ncfreelist = (cm_nc_t *) 0;
473     memset (cm_data.nameCache, 0, sizeof(cm_nc_t) * NCSIZE);
474     memset (cm_data.nameHash, 0, sizeof(cm_nc_t *) * NHSIZE);
475     for (i=0; i<NCSIZE; i++)
476     {
477         cm_data.nameCache[i].magic = CM_DNLC_MAGIC;
478         cm_data.nameCache[i].next = cm_data.ncfreelist;
479         cm_data.ncfreelist = &cm_data.nameCache[i];
480     }
481     lock_ReleaseWrite(&cm_dnlcLock);
482    
483 }
484
485 /* remove everything referencing a specific volume */
486 /* is this function ever called? */
487 void
488 cm_dnlcPurgeVol(AFSFid *fidp)
489 {
490
491     if (!cm_useDnlc)
492         return ;
493
494     dnlcstats.purgevols++;
495     cm_dnlcPurge();
496 }
497
498 long
499 cm_dnlcValidate(void)
500 {
501     int i, purged = 0;
502     cm_nc_t * ncp;
503
504   retry:
505     // are all nameCache entries marked with the magic bit?
506     for (i=0; i<NCSIZE; i++)
507     {
508         if (cm_data.nameCache[i].magic != CM_DNLC_MAGIC) {
509             afsi_log("cm_dnlcValidate failure: cm_data.nameCache[%d].magic != CM_DNLC_MAGIC", i);
510             fprintf(stderr, "cm_dnlcValidate failure: cm_data.nameCache[%d].magic != CM_DNLC_MAGIC\n", i);
511             goto purge;
512         }
513         if (cm_data.nameCache[i].next &&
514             cm_data.nameCache[i].next->magic != CM_DNLC_MAGIC) {
515             afsi_log("cm_dnlcValidate failure: cm_data.nameCache[%d].next->magic != CM_DNLC_MAGIC", i);
516             fprintf(stderr, "cm_dnlcValidate failure: cm_data.nameCache[%d].next->magic != CM_DNLC_MAGIC\n", i);
517             goto purge;
518         }
519         if (cm_data.nameCache[i].prev &&
520             cm_data.nameCache[i].prev->magic != CM_DNLC_MAGIC) {
521             afsi_log("cm_dnlcValidate failure: cm_data.nameCache[%d].prev->magic != CM_DNLC_MAGIC", i);
522             fprintf(stderr, "cm_dnlcValidate failure: cm_data.nameCache[%d].prev->magic != CM_DNLC_MAGIC\n", i);
523             goto purge;
524         }
525         if (cm_data.nameCache[i].dirp &&
526             cm_data.nameCache[i].dirp->magic != CM_SCACHE_MAGIC) {
527             afsi_log("cm_dnlcValidate failure: cm_data.nameCache[%d].dirp->magic != CM_SCACHE_MAGIC", i);
528             fprintf(stderr, "cm_dnlcValidate failure: cm_data.nameCache[%d].dirp->magic != CM_SCACHE_MAGIC\n", i);
529             goto purge;
530         }
531         if (cm_data.nameCache[i].vp &&
532             cm_data.nameCache[i].vp->magic != CM_SCACHE_MAGIC) {
533             afsi_log("cm_dnlcValidate failure: cm_data.nameCache[%d].vp->magic != CM_SCACHE_MAGIC", i);
534             fprintf(stderr, "cm_dnlcValidate failure: cm_data.nameCache[%d].vp->magic != CM_SCACHE_MAGIC\n", i);
535             goto purge;
536         }
537     }
538
539     // are the contents of the hash table intact?
540     for (i=0; i<NHSIZE;i++) {
541         for (ncp = cm_data.nameHash[i]; ncp ; 
542              ncp = ncp->next != cm_data.nameHash[i] ? ncp->next : NULL) {
543             if (ncp->magic != CM_DNLC_MAGIC) {
544                 afsi_log("cm_dnlcValidate failure: ncp->magic != CM_DNLC_MAGIC");
545                 fprintf(stderr, "cm_dnlcValidate failure: ncp->magic != CM_DNLC_MAGIC\n");
546                 goto purge;
547             }
548             if (ncp->prev && ncp->prev->magic != CM_DNLC_MAGIC) {
549                 afsi_log("cm_dnlcValidate failure: ncp->prev->magic != CM_DNLC_MAGIC");
550                 fprintf(stderr, "cm_dnlcValidate failure: ncp->prev->magic != CM_DNLC_MAGIC\n");
551                 goto purge;
552             }
553             if (ncp->dirp && ncp->dirp->magic != CM_SCACHE_MAGIC) {
554                 afsi_log("cm_dnlcValidate failure: ncp->dirp->magic != CM_DNLC_MAGIC");
555                 fprintf(stderr, "cm_dnlcValidate failure: ncp->dirp->magic != CM_DNLC_MAGIC\n");
556                 goto purge;
557             }
558             if (ncp->vp && ncp->vp->magic != CM_SCACHE_MAGIC) {
559                 afsi_log("cm_dnlcValidate failure: ncp->vp->magic != CM_DNLC_MAGIC");
560                 fprintf(stderr, "cm_dnlcValidate failure: ncp->vp->magic != CM_DNLC_MAGIC\n");
561                 goto purge;
562             }
563         }
564     }
565
566     // is the freelist stable?
567     if ( cm_data.ncfreelist ) {
568         for (ncp = cm_data.ncfreelist, i = 0; ncp && i < NCSIZE; 
569              ncp = ncp->next != cm_data.ncfreelist ? ncp->next : NULL, i++) {
570             if (ncp->magic != CM_DNLC_MAGIC) {
571                 afsi_log("cm_dnlcValidate failure: ncp->magic != CM_DNLC_MAGIC");
572                 fprintf(stderr, "cm_dnlcValidate failure: ncp->magic != CM_DNLC_MAGIC\n");
573                 goto purge;
574             }
575             if (ncp->prev) {
576                 afsi_log("cm_dnlcValidate failure: ncp->prev != NULL");
577                 fprintf(stderr, "cm_dnlcValidate failure: ncp->prev != NULL\n");
578                 goto purge;
579             }
580             if (ncp->key) {
581                 afsi_log("cm_dnlcValidate failure: ncp->key != 0");
582                 fprintf(stderr, "cm_dnlcValidate failure: ncp->key != 0\n");
583                 goto purge;
584             }
585             if (ncp->dirp) {
586                 afsi_log("cm_dnlcValidate failure: ncp->dirp != NULL");
587                 fprintf(stderr, "cm_dnlcValidate failure: ncp->dirp != NULL\n");
588                goto purge;
589             }
590             if (ncp->vp) {
591                 afsi_log("cm_dnlcValidate failure: ncp->vp != NULL");
592                 fprintf(stderr, "cm_dnlcValidate failure: ncp->vp != NULL\n");
593                 goto purge;
594             }
595         }
596
597         if ( i == NCSIZE && ncp ) {
598             afsi_log("cm_dnlcValidate failure: dnlc freeList corrupted");
599             fprintf(stderr, "cm_dnlcValidate failure: dnlc freeList corrupted\n");
600             goto purge;
601         }
602     }
603     return 0;
604
605   purge:
606     if ( purged )
607         return -1;
608
609     afsi_log("cm_dnlcValidate information: purging");
610     fprintf(stderr, "cm_dnlcValidate information: purging\n");
611     cm_data.ncfreelist = (cm_nc_t *) 0;
612     memset (cm_data.nameCache, 0, sizeof(cm_nc_t) * NCSIZE);
613     memset (cm_data.nameHash, 0, sizeof(cm_nc_t *) * NHSIZE);
614     for (i=0; i<NCSIZE; i++)
615     {
616         cm_data.nameCache[i].magic = CM_DNLC_MAGIC;
617         cm_data.nameCache[i].next = cm_data.ncfreelist;
618         cm_data.ncfreelist = &cm_data.nameCache[i];
619     }
620     purged = 1;
621     goto retry;
622 }
623
624 void 
625 cm_dnlcInit(int newFile)
626 {
627     int i;
628
629     if (!cm_useDnlc)
630         return ;
631
632     if ( cm_debugDnlc )
633         osi_Log0(afsd_logp,"cm_dnlcInit");
634
635     memset (&dnlcstats, 0, sizeof(dnlcstats));
636
637     lock_InitializeRWLock(&cm_dnlcLock, "cm_dnlcLock");
638     if ( newFile ) {
639         lock_ObtainWrite(&cm_dnlcLock);
640         cm_data.ncfreelist = (cm_nc_t *) 0;
641         cm_data.nameCache = cm_data.dnlcBaseAddress;
642         memset (cm_data.nameCache, 0, sizeof(cm_nc_t) * NCSIZE);
643         cm_data.nameHash = (cm_nc_t **) (cm_data.nameCache + NCSIZE);
644         memset (cm_data.nameHash, 0, sizeof(cm_nc_t *) * NHSIZE);
645     
646         for (i=0; i<NCSIZE; i++)
647         {
648             cm_data.nameCache[i].magic = CM_DNLC_MAGIC;
649             cm_data.nameCache[i].next = cm_data.ncfreelist;
650             cm_data.ncfreelist = &cm_data.nameCache[i];
651         }
652         lock_ReleaseWrite(&cm_dnlcLock);
653     }
654 }
655
656 long 
657 cm_dnlcShutdown(void)
658 {
659     if ( cm_debugDnlc )
660         osi_Log0(afsd_logp,"cm_dnlcShutdown");
661
662     return 0;
663 }