paradynd/src/resource.C

   1 /*
   2  *  Copyright 1993 Jeff Hollingsworth.  All rights reserved.
   3  *
   4  */
   5
   6 #ifndef lint
   7 static char Copyright[] = "@(#) Copyright (c) 1993 Jeff Hollingsowrth\
   8     All rights reserved.";
   9
  10 static char rcsid[] = "@(#) $Header: /home/jaw/CVSROOT_20081103/CVSROOT/core/paradynd/src/resource.C,v 1.3 1994/02/24 04:32:36 markc Exp $";
  11 #endif
  12
  13 /*
  14  * resource.C - handle resource creation and queries.
  15  *
  16  * $Log: resource.C,v $
  17  * Revision 1.3  1994/02/24 04:32:36  markc
  18  * Changed header files to reflect igen changes.  main.C does not look at the number of command line arguments now.
  19  *
  20  * Revision 1.2  1994/02/01  18:46:55  hollings
  21  * Changes for adding perfConsult thread.
  22  *
  23  * Revision 1.1  1994/01/27  20:31:41  hollings
  24  * Iinital version of paradynd speaking dynRPC igend protocol.
  25  *
  26  * Revision 1.3  1993/07/13  18:30:02  hollings
  27  * new include file syntax.
  28  * expanded tempName to 255 chars for c++ support.
  29  *
  30  * Revision 1.2  1993/06/08  20:14:34  hollings
  31  * state prior to bc net ptrace replacement.
  32  *
  33  * Revision 1.1  1993/03/19  22:45:45  hollings
  34  * Initial revision
  35  *
  36  *
  37  */
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 #include "symtab.h"
  43 #include "process.h"
  44 #include "dyninstP.h"
  45 #include "util.h"
  46 #include "dyninstRPC.SRVR.h"
  47
  48 extern dynRPC *tp;
  49 HTable <resource>       allResources;
  50
  51 /*
  52  * handle the notification of resource creation and deletion.
  53  *
  54  */
  55
  56 _resourceRec rootNode(False);
  57
  58 resource rootResource = &rootNode;
  59
  60 resourceList getRootResources()
  61 {
  62     return(rootResource->children);
  63 }
  64
  65 char *getResourceName(resource r)
  66 {
  67     return(r->info.name);
  68 }
  69
  70 resource getResourceParent(resource r)
  71 {
  72     return(r->parent);
  73 }
  74
  75 resourceList getResourceChildren(resource r)
  76 {
  77     return(r->children);
  78 }
  79
  80 int getResourceCount(resourceList rl)
  81 {
  82     return(rl ? rl->count: 0);
  83 }
  84
  85 resource getNthResource(resourceList rl, int n)
  86 {
  87     if (n < rl->count) {
  88         return(rl->elements[n]);
  89     } else {
  90         return(NULL);
  91     }
  92 }
  93
  94 resourceInfo *getResourceInfo(resource r)
  95 {
  96     return(&r->info);
  97 }
  98
  99 resourceList createResourceList()
 100 {
 101     resourceList ret;
 102
 103     ret = (resourceList) xcalloc(sizeof(struct _resourceListRec), 1);
 104     return(ret);
 105 }
 106
 107 Boolean addResourceList(resourceList rl, resource r)
 108 {
 109
 110     if (rl->count == rl->maxItems) {
 111         rl->maxItems += 10;
 112         if (rl->elements) {
 113             rl->elements = (resource *)
 114                 xrealloc(rl->elements, sizeof(resource) * rl->maxItems);
 115         } else {
 116             rl->elements = (resource *) xmalloc(sizeof(resource) * rl->maxItems);
 117         }
 118     }
 119     rl->elements[rl->count] = r;
 120     rl->count++;
 121     return(True);
 122 }
 123
 124 Boolean initResourceRoot;
 125
 126 resource newResource(resource parent,
 127                      void *handle,
 128                      char *name,
 129                      timeStamp creation)
 130 {
 131     int c;
 132     char *iName;
 133     resource ret;
 134     resource *curr;
 135     char tempName[255];
 136
 137     if (!initResourceRoot) {
 138         initResourceRoot = True;
 139         rootNode.info.name = "";
 140         rootNode.info.fullName = "";
 141         rootNode.info.creation = 0.0;
 142         rootNode.parent = NULL;
 143         rootNode.handle = NULL;
 144         rootNode.children = NULL;
 145     }
 146
 147     iName = pool.findAndAdd(name);
 148
 149     /* first check to see if the resource has already been defined */
 150     if (parent->children) {
 151         for (curr=parent->children->elements, c=0;
 152              c < parent->children->count; c++) {
 153              if (curr[c]->info.name == iName) {
 154                  return(curr[c]);
 155              }
 156         }
 157     } else {
 158         parent->children = (resourceList)
 159             xcalloc(sizeof(struct _resourceListRec), 1);
 160     }
 161
 162     ret = new(_resourceRec);
 163     ret->parent = parent;
 164     ret->handle = handle;
 165
 166     sprintf(tempName, "%s/%s", parent->info.fullName, name);
 167     ret->info.fullName = pool.findAndAdd(tempName);
 168     ret->info.name = iName;
 169
 170     ret->info.creation = creation;
 171
 172     addResourceList(parent->children, ret);
 173     allResources.add(ret, (void *) ret->info.fullName);
 174
 175     /* call notification upcall */
 176     tp->resourceInfoCallback(0, parent->info.fullName, ret->info.name,
 177          ret->info.name);
 178
 179     return(ret);
 180 }
 181
 182 resource findChildResource(resource parent, char *name)
 183 {
 184     int c;
 185     char *iName;
 186     resource *curr;
 187
 188     iName = pool.findAndAdd(name);
 189
 190     if (!parent || !parent->children) return(NULL);
 191     for (curr=parent->children->elements, c=0;
 192          c < parent->children->count; c++) {
 193          if (curr[c]->info.name == iName) {
 194              return(curr[c]);
 195          }
 196     }
 197     return(NULL);
 198 }
 199
 200 void printResources(resource r)
 201 {
 202     int c;
 203     resource *curr;
 204
 205     if (r) {
 206         printf("%s\n", r->info.fullName);
 207         if (r->children) {
 208             for (curr=r->children->elements, c=0;
 209                  c < r->children->count; c++) {
 210                  printResources(curr[c]);
 211             }
 212         }
 213     }
 214 }
 215
 216 void printResourceList(resourceList rl)
 217 {
 218     int i;
 219
 220     printf("<");
 221     for (i=0; i < rl->count; i++) {
 222         printf(rl->elements[i]->info.fullName);
 223         if (i!= rl->count-1) printf(",");
 224     }
 225     printf(">");
 226 }
 227
 228 /*
 229  * Convinence function.
 230  *
 231  */
 232 Boolean isResourceDescendent(resource parent, resource child)
 233 {
 234     while (child) {
 235         if (child == parent) {
 236             return(True);
 237         } else {
 238             child = getResourceParent(child);
 239         }
 240     }
 241     return(False);
 242 }
 243
 244 //
 245 // Find this passed focus if its resource compoents are valid for this paradynd.
 246 //    We treat "unknown" top level resources as a specical case since the
 247 //    meaning is that we are at the top level of refinement of an unsupported
 248 //    resource hierarchy.  In this case, we simply create the resource, and
 249 //    the focus is valid.  Any other resource that can't be found results in
 250 //    an invalid focus.  jkh 1/29/94.
 251 //
 252 resourceList findFocus(int count, char **data)
 253 {
 254     int i;
 255     char *iName;
 256     resource res;
 257     resourceList rl;
 258
 259     rl = createResourceList();
 260     for (i=0; i < count; i++) {
 261         iName = pool.findAndAdd(data[i]);
 262         res = allResources.find(iName);
 263         if (!res && (strchr(iName, '/') == strrchr(iName, '/'))) {
 264             res = newResource(rootResource, NULL, ++iName, 0.0);
 265         } else if (!res) {
 266             return(NULL);
 267         }
 268         addResourceList(rl, res);
 269     }
 270     return(rl);
 271 }
 272
 273 resource findResource(char *name)
 274 {
 275     char *iName;
 276     resource res;
 277
 278     if (*name == '\0') {
 279         return(rootResource);
 280     } else {
 281         iName = pool.findAndAdd(name);
 282         res = allResources.find(iName);
 283         return(res);
 284     }
 285 }