minix/lib/libsys/ds.c

   1
   2 #include <minix/ds.h>
   3 #include <string.h>
   4
   5 #include "syslib.h"
   6
   7 static int do_invoke_ds(message *m, int type, const char *ds_name)
   8 {
   9         cp_grant_id_t g_key;
  10         size_t len_key;
  11         int access, r;
  12
  13         if(type == DS_CHECK || type == DS_RETRIEVE_LABEL) {
  14                 len_key = DS_MAX_KEYLEN;
  15                 access = CPF_WRITE;
  16         } else {
  17                 len_key = strlen(ds_name)+1;
  18                 access = CPF_READ;
  19         }
  20
  21         /* Grant for key. */
  22         g_key = cpf_grant_direct(DS_PROC_NR, (vir_bytes) ds_name,
  23                 len_key, access);
  24         if(!GRANT_VALID(g_key))
  25                 return ENOMEM;
  26
  27         m->m_ds_req.key_grant = g_key;
  28         m->m_ds_req.key_len = len_key;
  29
  30         r = _taskcall(DS_PROC_NR, type, m);
  31
  32         cpf_revoke(g_key);
  33         return r;
  34 }
  35
  36 int ds_publish_label(const char *ds_name, endpoint_t endpoint, int flags)
  37 {
  38         message m;
  39
  40         memset(&m, 0, sizeof(m));
  41         m.m_ds_req.val_in.ep = endpoint;
  42         m.m_ds_req.flags = DSF_TYPE_LABEL | flags;
  43         return do_invoke_ds(&m, DS_PUBLISH, ds_name);
  44 }
  45
  46 int ds_publish_u32(const char *ds_name, u32_t value, int flags)
  47 {
  48         message m;
  49
  50         memset(&m, 0, sizeof(m));
  51         m.m_ds_req.val_in.u32 = value;
  52         m.m_ds_req.flags = DSF_TYPE_U32 | flags;
  53         return do_invoke_ds(&m, DS_PUBLISH, ds_name);
  54 }
  55
  56 static int ds_publish_raw(const char *ds_name, void *vaddr, size_t length,
  57         int flags)
  58 {
  59         cp_grant_id_t gid;
  60         message m;
  61         int r;
  62
  63         /* Grant for memory range. */
  64         gid = cpf_grant_direct(DS_PROC_NR, (vir_bytes)vaddr, length, CPF_READ);
  65         if(!GRANT_VALID(gid))
  66                 return ENOMEM;
  67
  68         memset(&m, 0, sizeof(m));
  69         m.m_ds_req.val_in.grant = gid;
  70         m.m_ds_req.val_len = length;
  71         m.m_ds_req.flags = flags;
  72
  73         r = do_invoke_ds(&m, DS_PUBLISH, ds_name);
  74         cpf_revoke(gid);
  75
  76         return r;
  77 }
  78
  79 int ds_publish_str(const char *ds_name, char *value, int flags)
  80 {
  81         size_t length;
  82         length = strlen(value) + 1;
  83         value[length - 1] = '\0';
  84         return ds_publish_raw(ds_name, value, length, flags | DSF_TYPE_STR);
  85 }
  86
  87 int ds_publish_mem(const char *ds_name, void *vaddr, size_t length, int flags)
  88 {
  89         return ds_publish_raw(ds_name, vaddr, length, flags | DSF_TYPE_MEM);
  90 }
  91
  92 int ds_retrieve_label_name(char *ds_name, endpoint_t endpoint)
  93 {
  94         message m;
  95         int r;
  96
  97         memset(&m, 0, sizeof(m));
  98         m.m_ds_req.val_in.ep = endpoint;
  99         r = do_invoke_ds(&m, DS_RETRIEVE_LABEL, ds_name);
 100         return r;
 101 }
 102
 103 int ds_retrieve_label_endpt(const char *ds_name, endpoint_t *endpoint)
 104 {
 105         message m;
 106         int r;
 107
 108         memset(&m, 0, sizeof(m));
 109         m.m_ds_req.flags = DSF_TYPE_LABEL;
 110         r = do_invoke_ds(&m, DS_RETRIEVE, ds_name);
 111         *endpoint = m.m_ds_reply.val_out.ep;
 112         return r;
 113 }
 114
 115 int ds_retrieve_u32(const char *ds_name, u32_t *value)
 116 {
 117         message m;
 118         int r;
 119
 120         memset(&m, 0, sizeof(m));
 121         m.m_ds_req.flags = DSF_TYPE_U32;
 122         r = do_invoke_ds(&m, DS_RETRIEVE, ds_name);
 123         *value = m.m_ds_reply.val_out.u32;
 124         return r;
 125 }
 126
 127 static int ds_retrieve_raw(const char *ds_name, char *vaddr, size_t *length,
 128         int flags)
 129 {
 130         message m;
 131         cp_grant_id_t gid;
 132         int r;
 133
 134         /* Grant for memory range. */
 135         gid = cpf_grant_direct(DS_PROC_NR, (vir_bytes)vaddr, *length, CPF_WRITE);
 136         if(!GRANT_VALID(gid))
 137                 return ENOMEM;
 138
 139         memset(&m, 0, sizeof(m));
 140         m.m_ds_req.val_in.grant = gid;
 141         m.m_ds_req.val_len = *length;
 142         m.m_ds_req.flags = flags;
 143         r = do_invoke_ds(&m, DS_RETRIEVE, ds_name);
 144         *length = m.m_ds_reply.val_len;
 145         cpf_revoke(gid);
 146
 147         return r;
 148 }
 149
 150 int ds_retrieve_str(const char *ds_name, char *value, size_t len_str)
 151 {
 152         int r;
 153         size_t length = len_str + 1;
 154         r = ds_retrieve_raw(ds_name, value, &length, DSF_TYPE_STR);
 155         value[length - 1] = '\0';
 156         return r;
 157 }
 158
 159 int ds_retrieve_mem(const char *ds_name, char *vaddr, size_t *length)
 160 {
 161         return ds_retrieve_raw(ds_name, vaddr, length, DSF_TYPE_MEM);
 162 }
 163
 164 int ds_delete_u32(const char *ds_name)
 165 {
 166         message m;
 167
 168         memset(&m, 0, sizeof(m));
 169         m.m_ds_req.flags = DSF_TYPE_U32;
 170         return do_invoke_ds(&m, DS_DELETE, ds_name);
 171 }
 172
 173 int ds_delete_str(const char *ds_name)
 174 {
 175         message m;
 176
 177         memset(&m, 0, sizeof(m));
 178         m.m_ds_req.flags = DSF_TYPE_STR;
 179         return do_invoke_ds(&m, DS_DELETE, ds_name);
 180 }
 181
 182 int ds_delete_mem(const char *ds_name)
 183 {
 184         message m;
 185
 186         memset(&m, 0, sizeof(m));
 187         m.m_ds_req.flags = DSF_TYPE_MEM;
 188         return do_invoke_ds(&m, DS_DELETE, ds_name);
 189 }
 190
 191 int ds_delete_label(const char *ds_name)
 192 {
 193         message m;
 194
 195         memset(&m, 0, sizeof(m));
 196         m.m_ds_req.flags = DSF_TYPE_LABEL;
 197         return do_invoke_ds(&m, DS_DELETE, ds_name);
 198 }
 199
 200 int ds_subscribe(const char *regexp, int flags)
 201 {
 202         message m;
 203
 204         memset(&m, 0, sizeof(m));
 205         m.m_ds_req.flags = flags;
 206         return do_invoke_ds(&m, DS_SUBSCRIBE, regexp);
 207 }
 208
 209 int ds_check(char *ds_key, int *type, endpoint_t *owner_e)
 210 {
 211         message m;
 212         int r;
 213
 214         memset(&m, 0, sizeof(m));
 215         r = do_invoke_ds(&m, DS_CHECK, ds_key);
 216         if(type) *type = m.m_ds_req.flags;
 217         if(owner_e) *owner_e = m.m_ds_req.owner;
 218         return r;
 219 }