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