Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 pj 1
/*
2
 * Project: S.Ha.R.K.
3
 *
4
 * Coordinators:
5
 *   Giorgio Buttazzo    <giorgio@sssup.it>
6
 *   Paolo Gai           <pj@gandalf.sssup.it>
7
 *
8
 * Authors     :
9
 *   Paolo Gai           <pj@gandalf.sssup.it>
10
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
11
 *   Luca Abeni          <luca@gandalf.sssup.it>
12
 *   (see the web pages for full authors list)
13
 *
14
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
15
 *
16
 * http://www.sssup.it
17
 * http://retis.sssup.it
18
 * http://shark.sssup.it
19
 */
20
 
21
/**
22
 ------------
23
 CVS :        $Id: hartport.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
24
 
25
 File:        $File$
26
 Revision:    $Revision: 1.1.1.1 $
27
 Last update: $Date: 2002-03-29 14:12:52 $
28
 ------------
29
 
30
 This file contains the Hartik 3.3.1 Port functions
31
 
32
 Author:      Giuseppe Lipari
33
 Date:        2/7/96
34
 
35
 File:  Port.C (renamed to hartport.c)
36
 Revision:    1.4
37
 
38
**/
39
 
40
/*
41
 * Copyright (C) 2000 Paolo Gai
42
 *
43
 * This program is free software; you can redistribute it and/or modify
44
 * it under the terms of the GNU General Public License as published by
45
 * the Free Software Foundation; either version 2 of the License, or
46
 * (at your option) any later version.
47
 *
48
 * This program is distributed in the hope that it will be useful,
49
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
50
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
51
 * GNU General Public License for more details.
52
 *
53
 * You should have received a copy of the GNU General Public License
54
 * along with this program; if not, write to the Free Software
55
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
56
 *
57
 */
58
 
59
 
60
#include <modules/hartport.h>
61
#include <kernel/config.h>
62
#include <ll/ll.h>
63
#include <ll/string.h>
64
#include <ll/stdio.h>
65
#include <kernel/model.h>
66
#include <kernel/const.h>
67
#include <sys/types.h>
68
#include <kernel/descr.h>
69
#include <errno.h>
70
#include <kernel/var.h>
71
#include <kernel/func.h>
72
 
73
 
74
static sem_t hash_mutex;
75
 
76
#define __PORT_DBG__
77
 
78
struct hash_port {
79
        char    name[MAX_PORT_NAME];
80
        PID     port_index;
81
        BYTE    blocked;
82
        sem_t   sem;
83
        BYTE    valid;
84
        int     port_int;
85
};
86
 
87
struct port_ker {
88
        BYTE    valid;
89
        int     next;
90
        WORD    dim_block;
91
        BYTE    *mem_block;
92
        BYTE    *head;
93
        BYTE    *tail;
94
        BYTE    type;
95
        sem_t   mutex;
96
        sem_t   pieno;
97
        sem_t   vuoto;
98
};
99
 
100
struct port_com {
101
        BYTE    valid;
102
        int     next;
103
        PID     proc_id;
104
        BYTE    access;
105
        int     port_index;
106
        WORD    dim_mes;
107
        int     h_index;
108
};
109
 
110
struct hash_port        htable[MAX_HASH_ENTRY];
111
struct port_ker         port_des[MAX_PORT];
112
struct port_com         port_int[MAX_PORT_INT];
113
QUEUE   freeportdes;
114
QUEUE   freeportint;
115
 
116
static int port_installed = 0;
117
 
118
 
119
/*----------------------------------------------------------------------*/
120
/* port_init() : inizializza le strutture delle porte; da chiamare      */
121
/* dentro __hartik_register_levels__().                                 */
122
/*----------------------------------------------------------------------*/
123
void HARTPORT_init(void)
124
{
125
    int i;
126
 
127
    if (port_installed)
128
      return;
129
    port_installed = 1;
130
 
131
    /* Init hash table                  */
132
    for (i = 0; i < MAX_HASH_ENTRY; i++) {
133
        htable[i].valid = FALSE;
134
        htable[i].port_int = NIL;
135
        htable[i].blocked = 0;
136
    }
137
 
138
    /* mutex sem on the hash table              */
139
    sem_init(&hash_mutex, 0, 1);
140
 
141
    /* init the port descriptor table   */
142
    for (i = 0; i < MAX_PORT - 1; i++) {
143
        port_des[i].next = i+1;
144
        port_des[i].valid = FALSE;
145
    }
146
    port_des[MAX_PORT - 1].next = NIL;
147
    port_des[MAX_PORT - 1].valid = FALSE;
148
    freeportdes = 0;
149
 
150
    /* Init the port interface table    */
151
    for (i = 0; i < MAX_PORT_INT - 1; i++) {
152
        port_int[i].next = i+1;
153
        port_int[i].valid = FALSE;
154
    }
155
    port_int[MAX_PORT_INT - 1].next = NIL;
156
    port_int[MAX_PORT_INT - 1].valid = FALSE;
157
//    for (i = PORT_NO_MORE_DESCR; i <= PORT_UNVALID_DESCR; i++)
158
//        exc_set(i,port_exception);
159
    freeportint = 0;
160
}
161
 
162
 
163
/*----------------------------------------------------------------------*/
164
/* hash_fun() : address hash table                                      */
165
/*----------------------------------------------------------------------*/
166
static int hash_fun(char *name)
167
{
168
    return (*name % MAX_HASH_ENTRY);
169
}
170
 
171
 
172
/*----------------------------------------------------------------------*/
173
/* getfreedes : restituisce l'indice di un descrittore di porta libero  */
174
/*----------------------------------------------------------------------*/
175
static int getfreedes(void)
176
{
177
    int p;
178
 
179
    kern_cli();
180
    if (freeportdes == NIL) {
181
        errno = EPORT_NO_MORE_DESCR;
182
        kern_sti();
183
        return -1;
184
    }
185
    p = freeportdes;
186
    freeportdes = port_des[p].next;
187
    kern_sti();
188
    return(p);
189
}        
190
 
191
/*----------------------------------------------------------------------*/
192
/* ungetdes() : mette il descrittore tra quelli disponibile             */
193
/*----------------------------------------------------------------------*/
194
static void ungetdes(int pd)
195
{
196
    kern_cli();
197
    port_des[pd].next = freeportdes;
198
    freeportdes = pd;
199
    kern_sti();
200
}
201
 
202
/*----------------------------------------------------------------------*/
203
/* get freeint : restituisce una interfaccia di porta libera            */
204
/*----------------------------------------------------------------------*/
205
static int getfreeint(void)
206
{
207
    int p;
208
 
209
    kern_cli();
210
    if (freeportint == NIL) {
211
        errno = EPORT_NO_MORE_INTERF;
212
        kern_sti();
213
        return -1;
214
    }
215
    p = freeportint;
216
    freeportint = port_int[p].next;
217
    kern_sti();
218
    return(p);
219
}      
220
 
221
/*----------------------------------------------------------------------*/
222
/* ungetint : rende disponibile l'interfaccia di porta specificata      */
223
/*----------------------------------------------------------------------*/
224
static void ungetint(int pi)
225
{
226
    kern_cli();
227
    port_int[pi].next = freeportint;
228
    freeportint = pi;
229
    kern_sti();
230
}
231
 
232
/*----------------------------------------------------------------------*/
233
/* port_create(): Apre la porta specificata dalla stringa, effettuando  */
234
/* automaticamente il collegamento                                      */
235
/* WARNING : La funzione e' bloccante per la mutua esclusione sulla     */
236
/* hash table                                                   */
237
/*----------------------------------------------------------------------*/
238
PORT port_create(char *name, int dim_mes, int num_mes, BYTE type, BYTE access)
239
{
240
    int i, pd, pi;
241
    WORD letti = 0;
242
    BYTE flag = FALSE;
243
 
244
/*
245
   Prendo un descrittore di porta.
246
*/
247
    #ifdef __PORT_DBG__
248
        if ((type == MAILBOX) && (access == WRITE)) {
249
           errno = EPORT_INCOMPAT_MESSAGE;
250
           return -1;
251
        }
252
        if ((type == STICK  ) && (access == READ )) {
253
           errno = EPORT_INCOMPAT_MESSAGE;
254
           return -1;
255
        }
256
    #endif
257
    pd = getfreedes();
258
    if (pd == -1) return -1;
259
/*
260
   Devo andare in mutua esclusione sulla tabella di hash ! Poiche' questa
261
   viene acceduta dalle openport e dalle connect sono sicuro che una
262
   connect non puo' interrompere una openport.
263
*/
264
    sem_wait(&hash_mutex);
265
/*
266
   Scorro la tabella di hash fino a trovare un'entrata libera, oppure
267
   una entrata occupata in precedenza da una connect che ci si e' bloccata
268
   sopra (blocked > 0). Se ne trovo una gia' aperta da un'altra openport
269
   esco con errore. Lo stesso se sono state occupate tutte le entrate della
270
   tabella (tramite la var. letti);
271
*/
272
    i = hash_fun(name);
273
    while (!flag) {
274
        if (htable[i].valid == FALSE) flag = TRUE;
275
        else {
276
            if (strcmp(htable[i].name,name) == 0) {
277
                if (htable[i].blocked == 0) {
278
                    errno = EPORT_ALREADY_OPEN;
279
                    sem_post(&hash_mutex);
280
                    return -1;
281
                }
282
                else flag = TRUE;
283
            }
284
            else {
285
                i = (i+1) % MAX_HASH_ENTRY;
286
                letti++;
287
            }
288
        }
289
        if (letti > MAX_HASH_ENTRY-1) {
290
            errno = EPORT_NO_MORE_HASHENTRY;
291
            sem_post(&hash_mutex);
292
            return -1;
293
        }
294
 
295
    }
296
    htable[i].valid = TRUE;
297
    strcpy(htable[i].name, name);
298
 
299
    htable[i].port_index = pd;
300
/*
301
   A questo punto inizializzo tutta la struttura del descrittore di porta
302
*/
303
    if (type == STICK)  port_des[pd].dim_block = dim_mes;
304
    else port_des[pd].dim_block = dim_mes * num_mes;
305
 
306
    kern_cli();
307
    port_des[pd].mem_block = kern_alloc(port_des[pd].dim_block);
308
    kern_sti();
309
    if (port_des[pd].mem_block == NULL) {
310
        errno = EPORT_2_CONNECT;
311
        sem_post(&hash_mutex);
312
        return -1;
313
    }
314
 
315
    port_des[pd].head = port_des[pd].tail = port_des[pd].mem_block;
316
 
317
    sem_init(&port_des[pd].mutex,0,1);
318
    sem_init(&port_des[pd].pieno,0,port_des[pd].dim_block);
319
    sem_init(&port_des[pd].vuoto,0,0);
320
    port_des[pd].type = type;
321
/*
322
   Prendo e inizializzo la struttura dell'interfaccia di porta verso il
323
   processo (e' la varibile pi quella che restituisco)
324
*/
325
    pi = getfreeint();
326
    if (pi == -1) {
327
        sem_post(&hash_mutex);
328
        return -1;
329
    }
330
 
331
/*  port_int[pi].proc_id = exec_shadow; */
332
    port_int[pi].access = access;
333
    port_int[pi].port_index = pd;
334
    port_int[pi].dim_mes = dim_mes;
335
    port_int[pi].next = NIL;
336
    port_int[pi].h_index = i;
337
    port_des[pd].valid = TRUE;
338
    port_int[pi].valid = TRUE;
339
/*
340
   Sblocco eventuali processi che avevano fatto la connect nella coda
341
   semaforica che sta nell'entrata relativa della hash table !
342
*/
343
    if (htable[i].blocked > 0) {
344
        sem_xpost(&htable[i].sem, htable[i].blocked);
345
        htable[i].blocked = 0;
346
        sem_destroy(&htable[i].sem);
347
    }
348
/*
349
   Infine libero la mutua esclusione.
350
*/
351
    sem_post(&hash_mutex);
352
    return (pi);
353
}
354
 
355
/*----------------------------------------------------------------------*/
356
/* port_connect(): collega la porta specificata dalla stringa.          */
357
/* WARNING : La funzione e' bloccante per la mutua esclusione sulle     */
358
/* strutture delle porte                                                */
359
/*----------------------------------------------------------------------*/
360
PORT port_connect(char *name, int dim_mes, BYTE type, BYTE access)
361
{
362
    int i, pi, pd, pn,letti = 0;
363
    BYTE flag = FALSE, create = FALSE;
364
 
365
    #ifdef __PORT_DBG__
366
        if ((type == MAILBOX) && (access == READ )) {
367
            errno = EPORT_INCOMPAT_MESSAGE;
368
            return -1;
369
        }
370
        if ((type == STICK  ) && (access == WRITE)) {
371
           errno = EPORT_INCOMPAT_MESSAGE;
372
           return -1;
373
        }
374
    #endif
375
/*
376
   Per prima cosa mi prendo una interfaccia di porta e la riempio
377
   parzialmente.       
378
*/
379
    pi = getfreeint();
380
    if (pi == -1) return -1;
381
/*  port_int[pi].proc_id = exec_shadow; */
382
    port_int[pi].access = access;
383
    port_int[pi].dim_mes = dim_mes;
384
    port_int[pi].next = NIL;
385
/*
386
   Mutua esclusione sulla tabella di hash
387
*/
388
    sem_wait(&hash_mutex);
389
/*
390
   Cerco il descrittore appropriato : Se la porta e' gia' stata aperta
391
   allora esco dal ciclo con flag = TRUE, create = FALSE, l'indice i che
392
   punta all'entrata della tabella di hash, e con htable[i].blocked = 0;
393
   In tutti gli altri casi significa che la porta non e' stata aperta e
394
   quindi devo bloccarmi.
395
*/
396
    i = hash_fun(name);
397
    while (!flag) {
398
        /* Devo crearla */
399
        if (htable[i].valid == FALSE) {
400
            flag = TRUE;
401
            create = TRUE;
402
        }
403
        /* l'ho trovata (ma non so ancora se e' stata aperta) */
404
        else if (strcmp(htable[i].name, name) == 0) flag = TRUE;
405
        /* scandisco l'entrata successiva */
406
        else {
407
            i = (i+1) % MAX_HASH_ENTRY;
408
            letti ++;
409
        }
410
        #ifdef __PORT_DBG__
411
            /* se ho scorso tutto l'array senza trovare nulla */
412
            if (letti > MAX_HASH_ENTRY) {
413
                errno = EPORT_NO_MORE_HASHENTRY;
414
                sem_post(&hash_mutex);
415
                return -1;
416
            }
417
        #endif
418
    }
419
 
420
/*
421
   Se devo aspettare che venga aperta (create = TRUE) allora mi blocco in
422
   attesa sul semaforo della htable. Per non avere troppi semafori inutili
423
   in giro, me lo creo sul momento.
424
*/
425
    if (create == TRUE) {
426
        htable[i].valid = TRUE;
427
        htable[i].blocked = 1;
428
        strcpy(htable[i].name, name);
429
        sem_init(&htable[i].sem, 0, 0);
430
        sem_post(&hash_mutex);
431
        sem_xwait(&htable[i].sem,1,BLOCK);
432
    }
433
/*
434
   Se invece si e' gia' bloccata un'altra connect sopra, mi blocco anch'io.
435
   in ogni caso devo liberare la mutua esclusione sulla hash dato che ho
436
   gia' fatto tutto quello che dovevo fare con la hash.
437
*/
438
    else {
439
        if (htable[i].blocked > 0) {
440
            htable[i].blocked++;
441
            sem_post(&hash_mutex);
442
            sem_xwait(&htable[i].sem,1,BLOCK);
443
        }
444
        else sem_post(&hash_mutex);
445
    }
446
/*
447
   Controlli di errore.
448
*/
449
    pd = htable[i].port_index;
450
    #ifdef __PORT_DBG__
451
        if (type != port_des[pd].type) {
452
            errno = EPORT_UNSUPPORTED_ACC;
453
            return -1;
454
        }
455
        if ((type == STICK) && (dim_mes != port_des[pd].dim_block)) {
456
            errno = EPORT_WRONG_OP;
457
            return -1;
458
        }
459
        if ((type != STICK) && (port_des[pd].dim_block % dim_mes) != 0) {
460
            errno = EPORT_WRONG_OP;
461
            return -1;
462
        }
463
    #endif
464
 
465
    sem_wait(&hash_mutex);
466
    pn = htable[i].port_int;
467
    if (pn != NIL) {
468
        #ifdef __PORT_DBG__
469
            if (type == STREAM) {
470
                errno = EPORT_WRONG_TYPE;
471
                sem_post(&hash_mutex);
472
                return -1;
473
            }
474
            if (dim_mes != port_int[pn].dim_mes) {
475
                errno = EPORT_WRONG_OP;
476
                sem_post(&hash_mutex);
477
                return -1;
478
            }
479
        #endif
480
        port_int[pi].next = htable[i].port_int;
481
        htable[i].port_int = pi;
482
    }
483
    else htable[i].port_int = pi;
484
    sem_post(&hash_mutex);
485
    port_int[pi].h_index = i;
486
    port_int[pi].port_index = pd;
487
    port_int[pi].valid = TRUE;
488
    return(pi);
489
}
490
 
491
/*----------------------------------------------------------------------*/
492
/* port_delete() : inversa di port_open, libera tutto                   */
493
/*----------------------------------------------------------------------*/
494
void port_delete(PORT pi)
495
{
496
    int i;
497
    struct port_ker *pd;
498
    struct port_com *pp;
499
 
500
    pp = &port_int[pi];
501
    sem_wait(&hash_mutex);
502
    i = pp->h_index;
503
    pd = &port_des[htable[i].port_index];
504
    pd->valid = FALSE;
505
    sem_destroy(&pd->mutex);
506
    sem_destroy(&pd->pieno);
507
    sem_destroy(&pd->vuoto);
508
 
509
    kern_cli();
510
    kern_free(pd->mem_block, pd->dim_block);
511
    kern_sti();
512
 
513
    ungetdes(htable[i].port_index);
514
    pp->valid = FALSE;
515
    htable[i].port_int = pp->next;
516
    ungetint(pi);
517
    htable[i].valid = FALSE;
518
    sem_post(&hash_mutex);
519
}
520
 
521
/*----------------------------------------------------------------------*/
522
/* port_disconnect() : libera l'interfaccia di porta                    */
523
/*----------------------------------------------------------------------*/
524
void port_disconnect(PORT pi)
525
{
526
    sem_wait(&hash_mutex);
527
    if (htable[port_int[pi].h_index].valid == TRUE)
528
        htable[port_int[pi].h_index].port_int = port_int[pi].next;
529
    port_int[pi].valid = FALSE;
530
    ungetint(pi);
531
    sem_post(&hash_mutex);
532
}
533
 
534
/*----------------------------------------------------------------------*/
535
/* port_send() : Invia un messaggio alla porta                          */
536
/*----------------------------------------------------------------------*/
537
WORD port_send(PORT pi, void *msg, BYTE wait)
538
{
539
    struct port_ker *pd;
540
    struct port_com *pp;
541
 
542
    pp = &(port_int[pi]);
543
    pd = &(port_des[pp->port_index]);
544
 
545
    #ifdef __PORT_DBG__
546
        if (pp->access == READ) {
547
          errno = EPORT_WRONG_OP;
548
          return -1;
549
        }
550
        if (!pd->valid) {
551
          errno = EPORT_UNVALID_DESCR;
552
          return -1;
553
        }
554
 
555
    #endif
556
 
557
    if (pd->type == STICK) sem_wait(&pd->mutex);
558
    else if (pd->type == STREAM) {
559
            if (sem_xwait(&pd->pieno,pp->dim_mes,wait)) return(FALSE);
560
    }
561
    else {
562
        if (sem_xwait(&pd->pieno, pp->dim_mes,wait)) return(FALSE);
563
        sem_wait(&pd->mutex);
564
    }
565
 
566
    memcpy(pd->head, msg, pp->dim_mes);
567
 
568
    pd->head += pp->dim_mes;
569
 
570
    if (pd->head >= (pd->mem_block + pd->dim_block))
571
        pd->head -= pd->dim_block;
572
 
573
    if (pd->type == STICK) sem_post(&pd->mutex);
574
    else if (pd->type == STREAM) sem_xpost(&pd->vuoto, pp->dim_mes);
575
    else {
576
        sem_xpost(&pd->vuoto, pp->dim_mes);
577
        sem_post(&pd->mutex);
578
    }
579
    return(TRUE);
580
}
581
 
582
/*----------------------------------------------------------------------*/
583
/* port_receive() : Riceve un messaggio dalla porta                     */
584
/*----------------------------------------------------------------------*/
585
WORD port_receive(PORT pi,void *msg,BYTE wait)
586
{
587
    struct port_ker *pd;
588
    struct port_com *pp;
589
 
590
    pp = &(port_int[pi]);
591
    pd = &(port_des[pp->port_index]);
592
 
593
    #ifdef __PORT_DBG__
594
        if (pp->access == WRITE) {
595
          errno = EPORT_WRONG_OP;
596
          return -1;
597
        }
598
        if (!pd->valid) {
599
          errno = EPORT_UNVALID_DESCR;
600
          return -1;
601
        }
602
    #endif      
603
 
604
    if (pd->type == STICK) sem_wait(&pd->mutex);
605
    else if (pd->type == STREAM) {
606
         if (sem_xwait(&pd->vuoto,pp->dim_mes,wait)) return(FALSE);
607
    }
608
    else {
609
        if (sem_xwait(&pd->vuoto,pp->dim_mes,wait)) return(FALSE);
610
        sem_wait(&pd->mutex);
611
    }
612
 
613
    memcpy(msg, pd->tail, pp->dim_mes);
614
 
615
    pd->tail += pp->dim_mes;
616
    if (pd->tail >= (pd->mem_block + pd->dim_block))
617
        pd->tail -= pd->dim_block;
618
 
619
    if (pd->type == STICK) sem_post(&pd->mutex);
620
    else if (pd->type == STREAM) sem_xpost(&pd->pieno, pp->dim_mes);
621
    else {
622
        sem_xpost(&pd->pieno, pp->dim_mes);
623
        sem_post(&pd->mutex);
624
    }
625
    return(TRUE);
626
}
627
 
628
#ifdef __PORT_DBG__
629
 
630
void print_port(void)
631
{
632
    int i;
633
    struct port_ker *pd;
634
    struct port_com *pp;
635
 
636
/*
637
        kern_printf("Hash Table :\n");
638
        for (i=0; i<MAX_HASH_ENTRY; i++)
639
                kern_printf("%d\tvl: %d\tbl: %d\tpd: %d\t%s\n", i,
640
                        htable[i].valid, htable[i].blocked, htable[i].port_index,
641
                        htable[i].name);
642
*/
643
        kern_printf("Port des :\n");
644
        kern_printf("Free port des : %d\n", freeportdes);
645
        for (i=0; i<MAX_PORT_INT; i++)
646
            if (port_int[i].valid) {
647
                pp = &port_int[i];
648
                pd = &port_des[pp->port_index];
649
                kern_printf("%d %s  vt: %d      pn: %d\n",i,htable[pp->h_index].name,
650
                pd->vuoto,pd->pieno);
651
            }
652
/*
653
        kern_printf("Port int :\n");
654
        kern_printf("Free port int : %d\n", freeportint);
655
        for (i=0; i<MAX_PORT_INT; i++)
656
                kern_printf("%d  vl : %d  dm : %d  port_index : %d  proc_id : %d\n", i,
657
                        port_int[i].valid, port_int[i].dim_mes,
658
                        port_int[i].port_index, port_int[i].proc_id);
659
*/
660
}
661
 
662
void port_write(PORT p)
663
{
664
    struct port_ker *pd;
665
    struct port_com *pp;
666
    char msg[80];
667
 
668
    pp = &port_int[p];
669
    pd = &port_des[pp->port_index];
670
 
671
    kern_printf(msg,"%d  pd: %d   vt: %d      pn: %d ",p,pp->port_index,
672
        pd->vuoto,pd->pieno);
673
}
674
 
675
#endif