lib/libsys/ds.c

   1
   2 #include <minix/ds.h>
   3 #include <string.h>
   4
   5 #include "syslib.h"
   6
   7 static message m;
   8
   9 PRIVATE int do_invoke_ds(int type, const char *ds_name)
  10 {
  11         cp_grant_id_t g_key;
  12         size_t len_key;
  13         int access, r;
  14
  15         if(type == DS_CHECK || type == DS_RETRIEVE_LABEL) {
  16                 len_key = DS_MAX_KEYLEN;
  17                 access = CPF_WRITE;
  18         } else {
  19                 len_key = strlen(ds_name)+1;
  20                 access = CPF_READ;
  21         }
  22
  23         /* Grant for key. */
  24         g_key = cpf_grant_direct(DS_PROC_NR, (vir_bytes) ds_name,
  25                 len_key, access);
  26         if(!GRANT_VALID(g_key))
  27                 return errno;
  28
  29         m.DS_KEY_GRANT = g_key;
  30         m.DS_KEY_LEN = len_key;
  31
  32         r = _taskcall(DS_PROC_NR, type, &m);
  33
  34         cpf_revoke(g_key);
  35         return r;
  36 }
  37
  38 int ds_publish_label(const char *ds_name, u32_t value, int flags)
  39 {
  40         m.DS_VAL = value;
  41         m.DS_FLAGS = DSF_TYPE_LABEL | flags;
  42         return do_invoke_ds(DS_PUBLISH, ds_name);
  43 }
  44
  45 int ds_publish_u32(const char *ds_name, u32_t value, int flags)
  46 {
  47         m.DS_VAL = value;
  48         m.DS_FLAGS = DSF_TYPE_U32 | flags;
  49         return do_invoke_ds(DS_PUBLISH, ds_name);
  50 }
  51
  52 int ds_publish_str(const char *ds_name, char *value, int flags)
  53 {
  54         if(strlen(value) >= DS_MAX_STRLEN)
  55                 return EINVAL;
  56         strcpy((char *)(&m.DS_STRING), value);
  57         m.DS_FLAGS = DSF_TYPE_STR | flags;
  58         return do_invoke_ds(DS_PUBLISH, ds_name);
  59 }
  60
  61 int ds_publish_mem(const char *ds_name, void *vaddr, size_t length, int flags)
  62 {
  63         cp_grant_id_t gid;
  64         int r;
  65
  66         /* Grant for memory range. */
  67         gid = cpf_grant_direct(DS_PROC_NR, (vir_bytes)vaddr, length, CPF_READ);
  68         if(!GRANT_VALID(gid))
  69                 return errno;
  70
  71         m.DS_VAL = gid;
  72         m.DS_VAL_LEN = length;
  73         m.DS_FLAGS = DSF_TYPE_MEM | flags;
  74
  75         r = do_invoke_ds(DS_PUBLISH, ds_name);
  76         cpf_revoke(gid);
  77
  78         return r;
  79 }
  80
  81 int ds_publish_map(const char *ds_name, void *vaddr, size_t length, int flags)
  82 {
  83         cp_grant_id_t gid;
  84         int r;
  85
  86         if(((vir_bytes)vaddr % CLICK_SIZE != 0) || (length % CLICK_SIZE != 0))
  87                 return EINVAL;
  88
  89         /* Grant for mapped memory range. */
  90         gid = cpf_grant_direct(DS_PROC_NR, (vir_bytes)vaddr, length,
  91                         CPF_READ | CPF_MAP);
  92         if(!GRANT_VALID(gid))
  93                 return errno;
  94
  95         m.DS_VAL = gid;
  96         m.DS_VAL_LEN = length;
  97         m.DS_FLAGS = DSF_TYPE_MAP | flags;
  98
  99         r = do_invoke_ds(DS_PUBLISH, ds_name);
 100         cpf_revoke(gid);
 101
 102         return r;
 103 }
 104
 105 int ds_snapshot_map(const char *ds_name, int *nr_snapshot)
 106 {
 107         int r;
 108         r = do_invoke_ds(DS_SNAPSHOT, ds_name);
 109         *nr_snapshot = m.DS_NR_SNAPSHOT;
 110         return r;
 111 }
 112
 113 int ds_retrieve_label_name(char *ds_name, u32_t num)
 114 {
 115         int r;
 116         m.DS_VAL = num;
 117         r = do_invoke_ds(DS_RETRIEVE_LABEL, ds_name);
 118         return r;
 119 }
 120
 121 int ds_retrieve_label_num(const char *ds_name, u32_t *value)
 122 {
 123         int r;
 124         m.DS_FLAGS = DSF_TYPE_LABEL;
 125         r = do_invoke_ds(DS_RETRIEVE, ds_name);
 126         *value = m.DS_VAL;
 127         return r;
 128 }
 129
 130 int ds_retrieve_u32(const char *ds_name, u32_t *value)
 131 {
 132         int r;
 133         m.DS_FLAGS = DSF_TYPE_U32;
 134         r = do_invoke_ds(DS_RETRIEVE, ds_name);
 135         *value = m.DS_VAL;
 136         return r;
 137 }
 138
 139 int ds_retrieve_str(const char *ds_name, char *value, size_t len_str)
 140 {
 141         int r;
 142         m.DS_FLAGS = DSF_TYPE_STR;
 143         r = do_invoke_ds(DS_RETRIEVE, ds_name);
 144         strncpy(value, (char *)(&m.DS_STRING), DS_MAX_STRLEN);
 145         value[DS_MAX_STRLEN - 1] = '\0';
 146         return r;
 147 }
 148
 149 int ds_retrieve_mem(const char *ds_name, char *vaddr, size_t *length)
 150 {
 151         cp_grant_id_t gid;
 152         int r;
 153
 154         /* Grant for memory range. */
 155         gid = cpf_grant_direct(DS_PROC_NR, (vir_bytes)vaddr, *length, CPF_WRITE);
 156         if(!GRANT_VALID(gid))
 157                 return errno;
 158
 159         m.DS_VAL = gid;
 160         m.DS_VAL_LEN = *length;
 161         m.DS_FLAGS = DSF_TYPE_MEM;
 162         r = do_invoke_ds(DS_RETRIEVE, ds_name);
 163         *length = m.DS_VAL_LEN;
 164         cpf_revoke(gid);
 165
 166         return r;
 167 }
 168
 169 int ds_retrieve_map(const char *ds_name, char *vaddr, size_t *length,
 170                 int nr_snapshot, int flags)
 171 {
 172         cp_grant_id_t gid;
 173         int r;
 174
 175         /* Map a mapped memory range. */
 176         if(flags & DSMF_MAP_MAPPED) {
 177                 /* Request DS to grant. */
 178                 m.DS_FLAGS = DSF_TYPE_MAP | DSMF_MAP_MAPPED;
 179                 r = do_invoke_ds(DS_RETRIEVE, ds_name);
 180                 if(r != OK)
 181                         return r;
 182
 183                 /* Do the safemap. */
 184                 if(*length > m.DS_VAL_LEN)
 185                         *length = m.DS_VAL_LEN;
 186                 *length = (size_t) CLICK_FLOOR(*length);
 187                 r = sys_safemap(DS_PROC_NR, m.DS_VAL, 0,
 188                                 (vir_bytes)vaddr, *length, D, 0);
 189
 190         /* Copy mapped memory range or a snapshot. */
 191         } else if(flags & (DSMF_COPY_MAPPED|DSMF_COPY_SNAPSHOT)) {
 192                 /* Grant for memory range first. */
 193                 gid = cpf_grant_direct(DS_PROC_NR, (vir_bytes)vaddr,
 194                                 *length, CPF_WRITE);
 195                 if(!GRANT_VALID(gid))
 196                         return errno;
 197
 198                 m.DS_VAL = gid;
 199                 m.DS_VAL_LEN = *length;
 200                 if(flags & DSMF_COPY_MAPPED) {
 201                         m.DS_FLAGS = DSF_TYPE_MAP | DSMF_COPY_MAPPED;
 202                 }
 203                 else {
 204                         m.DS_NR_SNAPSHOT = nr_snapshot;
 205                         m.DS_FLAGS = DSF_TYPE_MAP | DSMF_COPY_SNAPSHOT;
 206                 }
 207                 r = do_invoke_ds(DS_RETRIEVE, ds_name);
 208                 *length = m.DS_VAL_LEN;
 209                 cpf_revoke(gid);
 210         }
 211         else {
 212                 return EINVAL;
 213         }
 214
 215         return r;
 216 }
 217
 218 int ds_delete_u32(const char *ds_name)
 219 {
 220         m.DS_FLAGS = DSF_TYPE_U32;
 221         return do_invoke_ds(DS_DELETE, ds_name);
 222 }
 223
 224 int ds_delete_str(const char *ds_name)
 225 {
 226         m.DS_FLAGS = DSF_TYPE_STR;
 227         return do_invoke_ds(DS_DELETE, ds_name);
 228 }
 229
 230 int ds_delete_mem(const char *ds_name)
 231 {
 232         m.DS_FLAGS = DSF_TYPE_MEM;
 233         return do_invoke_ds(DS_DELETE, ds_name);
 234 }
 235
 236 int ds_delete_map(const char *ds_name)
 237 {
 238         m.DS_FLAGS = DSF_TYPE_MAP;
 239         return do_invoke_ds(DS_DELETE, ds_name);
 240 }
 241
 242 int ds_delete_label(const char *ds_name)
 243 {
 244         m.DS_FLAGS = DSF_TYPE_LABEL;
 245         return do_invoke_ds(DS_DELETE, ds_name);
 246 }
 247
 248 int ds_subscribe(const char *regexp, int flags)
 249 {
 250         m.DS_FLAGS = flags;
 251         return do_invoke_ds(DS_SUBSCRIBE, regexp);
 252 }
 253
 254 int ds_check(char *ds_key, int *type)
 255 {
 256         int r;
 257         r = do_invoke_ds(DS_CHECK, ds_key);
 258         *type = m.DS_FLAGS;
 259         return r;
 260 }