minix/servers/ds/store.c

   1 #include "inc.h"
   2 #include "store.h"
   3
   4 /* Allocate space for the data store. */
   5 static struct data_store ds_store[NR_DS_KEYS];
   6 static struct subscription ds_subs[NR_DS_SUBS];
   7
   8 /*===========================================================================*
   9  *                            alloc_data_slot                                *
  10  *===========================================================================*/
  11 static struct data_store *alloc_data_slot(void)
  12 {
  13 /* Allocate a new data slot. */
  14   int i;
  15
  16   for (i = 0; i < NR_DS_KEYS; i++) {
  17         if (!(ds_store[i].flags & DSF_IN_USE))
  18                 return &ds_store[i];
  19   }
  20
  21   return NULL;
  22 }
  23
  24 /*===========================================================================*
  25  *                              alloc_sub_slot                               *
  26  *===========================================================================*/
  27 static struct subscription *alloc_sub_slot(void)
  28 {
  29 /* Allocate a new subscription slot. */
  30   int i;
  31
  32   for (i = 0; i < NR_DS_SUBS; i++) {
  33         if (!(ds_subs[i].flags & DSF_IN_USE))
  34                 return &ds_subs[i];
  35   }
  36
  37   return NULL;
  38 }
  39
  40 /*===========================================================================*
  41  *                              lookup_entry                                 *
  42  *===========================================================================*/
  43 static struct data_store *lookup_entry(const char *key_name, int type)
  44 {
  45 /* Lookup an existing entry by key and type. */
  46   int i;
  47
  48   for (i = 0; i < NR_DS_KEYS; i++) {
  49         if ((ds_store[i].flags & DSF_IN_USE) /* used */
  50                 && (ds_store[i].flags & type) /* same type*/
  51                 && !strcmp(ds_store[i].key, key_name)) /* same key*/
  52                 return &ds_store[i];
  53   }
  54
  55   return NULL;
  56 }
  57
  58 /*===========================================================================*
  59  *                           lookup_label_entry                              *
  60  *===========================================================================*/
  61 static struct data_store *lookup_label_entry(unsigned num)
  62 {
  63 /* Lookup an existing label entry by num. */
  64   int i;
  65
  66   for (i = 0; i < NR_DS_KEYS; i++) {
  67         if ((ds_store[i].flags & DSF_IN_USE)
  68                 && (ds_store[i].flags & DSF_TYPE_LABEL)
  69                 && (ds_store[i].u.u32 == num))
  70                 return &ds_store[i];
  71   }
  72
  73   return NULL;
  74 }
  75
  76 /*===========================================================================*
  77  *                            lookup_sub                                     *
  78  *===========================================================================*/
  79 static struct subscription *lookup_sub(const char *owner)
  80 {
  81 /* Lookup an existing subscription given its owner. */
  82   int i;
  83
  84   for (i = 0; i < NR_DS_SUBS; i++) {
  85         if ((ds_subs[i].flags & DSF_IN_USE) /* used */
  86                 && !strcmp(ds_subs[i].owner, owner)) /* same key*/
  87                 return &ds_subs[i];
  88   }
  89
  90   return NULL;
  91 }
  92
  93 /*===========================================================================*
  94  *                              ds_getprocname                               *
  95  *===========================================================================*/
  96 static char *ds_getprocname(endpoint_t e)
  97 {
  98 /* Get a process name given its endpoint. */
  99         struct data_store *dsp;
 100
 101         static char *first_proc_name = "ds";
 102         endpoint_t first_proc_ep = DS_PROC_NR;
 103
 104         if(e == first_proc_ep)
 105                 return first_proc_name;
 106
 107         if((dsp = lookup_label_entry(e)) != NULL)
 108                 return dsp->key;
 109
 110         return NULL;
 111 }
 112
 113 /*===========================================================================*
 114  *                              ds_getprocep                                 *
 115  *===========================================================================*/
 116 static endpoint_t ds_getprocep(const char *s)
 117 {
 118 /* Get a process endpoint given its name. */
 119         struct data_store *dsp;
 120
 121         if((dsp = lookup_entry(s, DSF_TYPE_LABEL)) != NULL)
 122                 return dsp->u.u32;
 123         panic("ds_getprocep: process endpoint not found");
 124 }
 125
 126 /*===========================================================================*
 127  *                               check_auth                                  *
 128  *===========================================================================*/
 129 static int check_auth(const struct data_store *p, endpoint_t ep, int perm)
 130 {
 131 /* Check authorization for a given type of permission. */
 132         char *source;
 133
 134         if(!(p->flags & perm))
 135                 return 1;
 136
 137         source = ds_getprocname(ep);
 138         return source && !strcmp(p->owner, source);
 139 }
 140
 141 /*===========================================================================*
 142  *                              get_key_name                                 *
 143  *===========================================================================*/
 144 static int get_key_name(const message *m_ptr, char *key_name)
 145 {
 146 /* Get key name given an input message. */
 147   int r;
 148
 149   if (m_ptr->m_ds_req.key_len > DS_MAX_KEYLEN || m_ptr->m_ds_req.key_len < 2) {
 150         printf("DS: bogus key length (%d) from %d\n", m_ptr->m_ds_req.key_len,
 151                 m_ptr->m_source);
 152         return EINVAL;
 153   }
 154
 155   /* Copy name from caller. */
 156   r = sys_safecopyfrom(m_ptr->m_source,
 157         (cp_grant_id_t) m_ptr->m_ds_req.key_grant, 0,
 158         (vir_bytes) key_name, m_ptr->m_ds_req.key_len);
 159   if(r != OK) {
 160         printf("DS: publish: copy failed from %d: %d\n", m_ptr->m_source, r);
 161         return r;
 162   }
 163
 164   key_name[DS_MAX_KEYLEN-1] = '\0';
 165
 166   return OK;
 167 }
 168
 169 /*===========================================================================*
 170  *                              check_sub_match                              *
 171  *===========================================================================*/
 172 static int check_sub_match(const struct subscription *subp,
 173                 struct data_store *dsp, endpoint_t ep)
 174 {
 175 /* Check if an entry matches a subscription. Return 1 in case of match. */
 176   return (check_auth(dsp, ep, DSF_PRIV_SUBSCRIBE)
 177           && regexec(&subp->regex, dsp->key, 0, NULL, 0) == 0)
 178           ? 1 : 0;
 179 }
 180
 181 /*===========================================================================*
 182  *                           update_subscribers                              *
 183  *===========================================================================*/
 184 static void update_subscribers(struct data_store *dsp, int set)
 185 {
 186 /* If set = 1, set bit in the sub bitmap of any subscription matching the given
 187  * entry, otherwise clear it. In both cases, notify the subscriber.
 188  */
 189         int i;
 190         int nr = dsp - ds_store;
 191         endpoint_t ep;
 192
 193         for(i = 0; i < NR_DS_SUBS; i++) {
 194                 if(!(ds_subs[i].flags & DSF_IN_USE))
 195                         continue;
 196                 if(!(ds_subs[i].flags & dsp->flags & DSF_MASK_TYPE))
 197                         continue;
 198
 199                 ep = ds_getprocep(ds_subs[i].owner);
 200                 if(!check_sub_match(&ds_subs[i], dsp, ep))
 201                         continue;
 202
 203                 if(set == 1) {
 204                         SET_BIT(ds_subs[i].old_subs, nr);
 205                 } else {
 206                         UNSET_BIT(ds_subs[i].old_subs, nr);
 207                 }
 208                 ipc_notify(ep);
 209         }
 210 }
 211
 212 /*===========================================================================*
 213  *                             map_service                                   *
 214  *===========================================================================*/
 215 static int map_service(const struct rprocpub *rpub)
 216 {
 217 /* Map a new service by registering its label. */
 218   struct data_store *dsp;
 219
 220   /* Allocate a new data slot. */
 221   if((dsp = alloc_data_slot()) == NULL) {
 222         return ENOMEM;
 223   }
 224
 225   /* Set attributes. */
 226   strcpy(dsp->key, rpub->label);
 227   dsp->u.u32 = (u32_t) rpub->endpoint;
 228   strcpy(dsp->owner, "rs");
 229   dsp->flags = DSF_IN_USE | DSF_TYPE_LABEL;
 230
 231   /* Update subscribers having a matching subscription. */
 232   update_subscribers(dsp, 1);
 233
 234   return(OK);
 235 }
 236
 237 /*===========================================================================*
 238  *                          sef_cb_init_fresh                                *
 239  *===========================================================================*/
 240 int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *info)
 241 {
 242 /* Initialize the data store server. */
 243         int i, r;
 244         struct rprocpub rprocpub[NR_BOOT_PROCS];
 245
 246         /* Reset data store: data and subscriptions. */
 247         for(i = 0; i < NR_DS_KEYS; i++) {
 248                 ds_store[i].flags = 0;
 249         }
 250         for(i = 0; i < NR_DS_SUBS; i++) {
 251                 ds_subs[i].flags = 0;
 252         }
 253
 254         /* Map all the services in the boot image. */
 255         if((r = sys_safecopyfrom(RS_PROC_NR, info->rproctab_gid, 0,
 256                 (vir_bytes) rprocpub, sizeof(rprocpub))) != OK) {
 257                 panic("sys_safecopyfrom failed: %d", r);
 258         }
 259         for(i=0;i < NR_BOOT_PROCS;i++) {
 260                 if(rprocpub[i].in_use) {
 261                         if((r = map_service(&rprocpub[i])) != OK) {
 262                                 panic("unable to map service: %d", r);
 263                         }
 264                 }
 265         }
 266
 267         return(OK);
 268 }
 269
 270 /*===========================================================================*
 271  *                              do_publish                                   *
 272  *===========================================================================*/
 273 int do_publish(message *m_ptr)
 274 {
 275   struct data_store *dsp;
 276   char key_name[DS_MAX_KEYLEN];
 277   char *source;
 278   int flags = m_ptr->m_ds_req.flags;
 279   size_t length;
 280   int r;
 281
 282   /* Lookup the source. */
 283   source = ds_getprocname(m_ptr->m_source);
 284   if(source == NULL)
 285           return EPERM;
 286
 287   /* Only RS can publish labels. */
 288   if((flags & DSF_TYPE_LABEL) && m_ptr->m_source != RS_PROC_NR)
 289           return EPERM;
 290
 291   /* Get key name. */
 292   if((r = get_key_name(m_ptr, key_name)) != OK)
 293         return r;
 294
 295   /* Lookup the entry. */
 296   dsp = lookup_entry(key_name, flags & DSF_MASK_TYPE);
 297   /* If type is LABEL, also try to lookup the entry by num. */
 298   if((flags & DSF_TYPE_LABEL) && (dsp == NULL))
 299         dsp = lookup_label_entry(m_ptr->m_ds_req.val_in.ep);
 300
 301   if(dsp == NULL) {
 302         /* The entry doesn't exist, allocate a new data slot. */
 303         if((dsp = alloc_data_slot()) == NULL)
 304                 return ENOMEM;
 305   } else if (flags & DSF_OVERWRITE) {
 306         /* Overwrite. */
 307         if(!check_auth(dsp, m_ptr->m_source, DSF_PRIV_OVERWRITE))
 308                 return EPERM;
 309   } else {
 310         /* Don't overwrite and return error. */
 311         return EEXIST;
 312   }
 313
 314   /* Store! */
 315   switch(flags & DSF_MASK_TYPE) {
 316   case DSF_TYPE_U32:
 317         dsp->u.u32 = m_ptr->m_ds_req.val_in.u32;
 318         break;
 319   case DSF_TYPE_LABEL:
 320         dsp->u.u32 = m_ptr->m_ds_req.val_in.ep;
 321         break;
 322   case DSF_TYPE_STR:
 323   case DSF_TYPE_MEM:
 324         length = m_ptr->m_ds_req.val_len;
 325         /* Allocate a new data buffer if necessary. */
 326         if(!(dsp->flags & DSF_IN_USE)) {
 327                 if((dsp->u.mem.data = malloc(length)) == NULL)
 328                         return ENOMEM;
 329                 dsp->u.mem.reallen = length;
 330         } else if(length > dsp->u.mem.reallen) {
 331                 free(dsp->u.mem.data);
 332                 if((dsp->u.mem.data = malloc(length)) == NULL)
 333                         return ENOMEM;
 334                 dsp->u.mem.reallen = length;
 335         }
 336
 337         /* Copy the memory range. */
 338         r = sys_safecopyfrom(m_ptr->m_source, m_ptr->m_ds_req.val_in.grant,
 339                 0, (vir_bytes) dsp->u.mem.data, length);
 340         if(r != OK) {
 341                 printf("DS: publish: memory map/copy failed from %d: %d\n",
 342                         m_ptr->m_source, r);
 343                 free(dsp->u.mem.data);
 344                 return r;
 345         }
 346         dsp->u.mem.length = length;
 347         if(flags & DSF_TYPE_STR) {
 348                 ((char*)dsp->u.mem.data)[length-1] = '\0';
 349         }
 350         break;
 351   default:
 352         return EINVAL;
 353   }
 354
 355   /* Set attributes. */
 356   strcpy(dsp->key, key_name);
 357   strcpy(dsp->owner, source);
 358   dsp->flags = DSF_IN_USE | (flags & DSF_MASK_INTERNAL);
 359
 360   /* Update subscribers having a matching subscription. */
 361   update_subscribers(dsp, 1);
 362
 363   return(OK);
 364 }
 365
 366 /*===========================================================================*
 367  *                              do_retrieve                                  *
 368  *===========================================================================*/
 369 int do_retrieve(message *m_ptr)
 370 {
 371   struct data_store *dsp;
 372   char key_name[DS_MAX_KEYLEN];
 373   int flags = m_ptr->m_ds_req.flags;
 374   int type = flags & DSF_MASK_TYPE;
 375   size_t length;
 376   int r;
 377
 378   /* Get key name. */
 379   if((r = get_key_name(m_ptr, key_name)) != OK)
 380         return r;
 381
 382   /* Lookup the entry. */
 383   if((dsp = lookup_entry(key_name, type)) == NULL)
 384         return ESRCH;
 385   if(!check_auth(dsp, m_ptr->m_source, DSF_PRIV_RETRIEVE))
 386         return EPERM;
 387
 388   /* Copy the requested data. */
 389   switch(type) {
 390   case DSF_TYPE_U32:
 391         m_ptr->m_ds_reply.val_out.u32 = dsp->u.u32;
 392         break;
 393   case DSF_TYPE_LABEL:
 394         m_ptr->m_ds_reply.val_out.ep = dsp->u.u32;
 395         break;
 396   case DSF_TYPE_STR:
 397   case DSF_TYPE_MEM:
 398         length = MIN(m_ptr->m_ds_req.val_len, dsp->u.mem.length);
 399         r = sys_safecopyto(m_ptr->m_source, m_ptr->m_ds_req.val_in.grant, 0,
 400                 (vir_bytes) dsp->u.mem.data, length);
 401         if(r != OK) {
 402                 printf("DS: retrieve: copy failed to %d: %d\n",
 403                         m_ptr->m_source, r);
 404                 return r;
 405         }
 406         m_ptr->m_ds_reply.val_len = length;
 407         break;
 408   default:
 409         return EINVAL;
 410   }
 411
 412   return OK;
 413 }
 414
 415 /*===========================================================================*
 416  *                              do_retrieve_label                            *
 417  *===========================================================================*/
 418 int do_retrieve_label(const message *m_ptr)
 419 {
 420   struct data_store *dsp;
 421   int r;
 422
 423   /* Lookup the label entry. */
 424   if((dsp = lookup_label_entry(m_ptr->m_ds_req.val_in.ep)) == NULL)
 425         return ESRCH;
 426
 427   /* Copy the key name. */
 428   r = sys_safecopyto(m_ptr->m_source,
 429         (cp_grant_id_t) m_ptr->m_ds_req.key_grant, (vir_bytes) 0,
 430         (vir_bytes) dsp->key, strlen(dsp->key) + 1);
 431   if(r != OK) {
 432         printf("DS: copy failed from %d: %d\n", m_ptr->m_source, r);
 433         return r;
 434   }
 435
 436   return OK;
 437 }
 438
 439 /*===========================================================================*
 440  *                              do_subscribe                                 *
 441  *===========================================================================*/
 442 int do_subscribe(message *m_ptr)
 443 {
 444   char regex[DS_MAX_KEYLEN+2];
 445   struct subscription *subp;
 446   char errbuf[80];
 447   char *owner;
 448   int type_set;
 449   int r, e, b;
 450
 451   /* Find the owner. */
 452   owner = ds_getprocname(m_ptr->m_source);
 453   if(owner == NULL)
 454           return ESRCH;
 455
 456   /* See if the owner already has an existing subscription. */
 457   if((subp = lookup_sub(owner)) == NULL) {
 458         /* The subscription doesn't exist, allocate a new one. */
 459         if((subp = alloc_sub_slot()) == NULL)
 460                 return EAGAIN;
 461   } else if(!(m_ptr->m_ds_req.flags & DSF_OVERWRITE)) {
 462         /* The subscription exists but we can't overwrite, return error. */
 463         return EEXIST;
 464   }
 465
 466   /* Copy key name from the caller. Anchor the subscription with "^regexp$" so
 467    * substrings don't match. The caller will probably not expect this,
 468    * and the usual case is for a complete match.
 469    */
 470   regex[0] = '^';
 471   if((r = get_key_name(m_ptr, regex+1)) != OK)
 472         return r;
 473   strcat(regex, "$");
 474
 475   /* Compile regular expression. */
 476   if((e=regcomp(&subp->regex, regex, REG_EXTENDED)) != 0) {
 477         regerror(e, &subp->regex, errbuf, sizeof(errbuf));
 478         printf("DS: subscribe: regerror: %s\n", errbuf);
 479         return EINVAL;
 480   }
 481
 482   /* If type_set = 0, then subscribe all types. */
 483   type_set = m_ptr->m_ds_req.flags & DSF_MASK_TYPE;
 484   if(type_set == 0)
 485           type_set = DSF_MASK_TYPE;
 486
 487   subp->flags = DSF_IN_USE | type_set;
 488   strcpy(subp->owner, owner);
 489   for(b = 0; b < BITMAP_CHUNKS(NR_DS_KEYS); b++)
 490         subp->old_subs[b] = 0;
 491
 492   /* See if caller requested an instant initial list. */
 493   if(m_ptr->m_ds_req.flags & DSF_INITIAL) {
 494         int i, match_found = FALSE;
 495         for(i = 0; i < NR_DS_KEYS; i++) {
 496                 if(!(ds_store[i].flags & DSF_IN_USE))
 497                         continue;
 498                 if(!(ds_store[i].flags & type_set))
 499                         continue;
 500                 if(!check_sub_match(subp, &ds_store[i], m_ptr->m_source))
 501                         continue;
 502
 503                 SET_BIT(subp->old_subs, i);
 504                 match_found = TRUE;
 505         }
 506
 507         /* Notify in case of match. */
 508         if(match_found)
 509                 ipc_notify(m_ptr->m_source);
 510   }
 511
 512   return OK;
 513 }
 514
 515 /*===========================================================================*
 516  *                              do_check                                     *
 517  *===========================================================================*/
 518 int do_check(message *m_ptr)
 519 {
 520   struct subscription *subp;
 521   char *owner;
 522   endpoint_t entry_owner_e;
 523   int r, i;
 524
 525   /* Find the subscription owner. */
 526   owner = ds_getprocname(m_ptr->m_source);
 527   if(owner == NULL)
 528           return ESRCH;
 529
 530   /* Lookup the owner's subscription. */
 531   if((subp = lookup_sub(owner)) == NULL)
 532         return ESRCH;
 533
 534   /* Look for an updated entry the subscriber is interested in. */
 535   for(i = 0; i < NR_DS_KEYS; i++) {
 536         if(GET_BIT(subp->old_subs, i))
 537                 break;
 538   }
 539   if(i == NR_DS_KEYS)
 540         return ENOENT;
 541
 542   /* Copy the key name. */
 543   r = sys_safecopyto(m_ptr->m_source,
 544         (cp_grant_id_t) m_ptr->m_ds_req.key_grant, (vir_bytes) 0,
 545         (vir_bytes) ds_store[i].key, strlen(ds_store[i].key) + 1);
 546   if(r != OK) {
 547         printf("DS: check: copy failed from %d: %d\n", m_ptr->m_source, r);
 548         return r;
 549   }
 550
 551   /* Copy the type and the owner of the original entry. */
 552   entry_owner_e = ds_getprocep(ds_store[i].owner);
 553   m_ptr->m_ds_req.flags = ds_store[i].flags & DSF_MASK_TYPE;
 554   m_ptr->m_ds_req.owner = entry_owner_e;
 555
 556   /* Mark the entry as no longer updated for the subscriber. */
 557   UNSET_BIT(subp->old_subs, i);
 558
 559   return OK;
 560 }
 561
 562 /*===========================================================================*
 563  *                              do_delete                                    *
 564  *===========================================================================*/
 565 int do_delete(message *m_ptr)
 566 {
 567   struct data_store *dsp;
 568   char key_name[DS_MAX_KEYLEN];
 569   char *source;
 570   char *label;
 571   int type = m_ptr->m_ds_req.flags & DSF_MASK_TYPE;
 572   int i, r;
 573
 574   /* Lookup the source. */
 575   source = ds_getprocname(m_ptr->m_source);
 576   if(source == NULL)
 577           return EPERM;
 578
 579   /* Get key name. */
 580   if((r = get_key_name(m_ptr, key_name)) != OK)
 581         return r;
 582
 583   /* Lookup the entry. */
 584   if((dsp = lookup_entry(key_name, type)) == NULL)
 585         return ESRCH;
 586
 587   /* Only the owner can delete. */
 588   if(strcmp(dsp->owner, source))
 589         return EPERM;
 590
 591   switch(type) {
 592   case DSF_TYPE_U32:
 593         break;
 594   case DSF_TYPE_LABEL:
 595         label = dsp->key;
 596
 597         /* Clean up subscriptions. */
 598         for (i = 0; i < NR_DS_SUBS; i++) {
 599                 if ((ds_subs[i].flags & DSF_IN_USE)
 600                         && !strcmp(ds_subs[i].owner, label)) {
 601                         ds_subs[i].flags = 0;
 602                 }
 603         }
 604
 605         /* Clean up data entries. */
 606         for (i = 0; i < NR_DS_KEYS; i++) {
 607                 if ((ds_store[i].flags & DSF_IN_USE)
 608                         && !strcmp(ds_store[i].owner, label)) {
 609                         update_subscribers(&ds_store[i], 0);
 610
 611                         ds_store[i].flags = 0;
 612                 }
 613         }
 614         break;
 615   case DSF_TYPE_STR:
 616   case DSF_TYPE_MEM:
 617         free(dsp->u.mem.data);
 618         break;
 619   default:
 620         return EINVAL;
 621   }
 622
 623   /* Update subscribers having a matching subscription. */
 624   update_subscribers(dsp, 0);
 625
 626   /* Clear the entry. */
 627   dsp->flags = 0;
 628
 629   return OK;
 630 }
 631
 632 /*===========================================================================*
 633  *                              do_getsysinfo                                *
 634  *===========================================================================*/
 635 int do_getsysinfo(const message *m_ptr)
 636 {
 637   vir_bytes src_addr;
 638   size_t length;
 639   int s;
 640
 641   switch(m_ptr->m_lsys_getsysinfo.what) {
 642   case SI_DATA_STORE:
 643         src_addr = (vir_bytes)ds_store;
 644         length = sizeof(struct data_store) * NR_DS_KEYS;
 645         break;
 646   default:
 647         return EINVAL;
 648   }
 649
 650   if (length != m_ptr->m_lsys_getsysinfo.size)
 651         return EINVAL;
 652
 653   if (OK != (s=sys_datacopy(SELF, src_addr,
 654                 m_ptr->m_source, m_ptr->m_lsys_getsysinfo.where, length))) {
 655         printf("DS: copy failed: %d\n", s);
 656         return s;
 657   }
 658
 659   return OK;
 660 }
 661