Subversion Repositories HelenOS

Rev

Rev 2359 | Rev 2494 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2359 Rev 2471
Line 47... Line 47...
47
#include <syscall/copy.h>
47
#include <syscall/copy.h>
48
#include <security/cap.h>
48
#include <security/cap.h>
49
#include <mm/as.h>
49
#include <mm/as.h>
50
#include <print.h>
50
#include <print.h>
51
 
51
 
52
#define GET_CHECK_PHONE(phone, phoneid, err) { \
52
#define GET_CHECK_PHONE(phone, phoneid, err) \
-
 
53
{ \
53
      if (phoneid > IPC_MAX_PHONES) { err; } \
54
    if (phoneid > IPC_MAX_PHONES) { \
-
 
55
        err; \
-
 
56
    } \
54
      phone = &TASK->phones[phoneid]; \
57
    phone = &TASK->phones[phoneid]; \
55
}
58
}
56
 
59
 
57
#define STRUCT_TO_USPACE(dst, src) copy_to_uspace(dst, src, sizeof(*(src)))
60
#define STRUCT_TO_USPACE(dst, src)  copy_to_uspace(dst, src, sizeof(*(src)))
58
 
61
 
59
/** Return true if the method is a system method */
62
/** Decide if the method is a system method.
-
 
63
 *
-
 
64
 * @param method    Method to be decided.
-
 
65
 *
-
 
66
 * @return      Return 1 if the method is a system method.
-
 
67
 *          Otherwise return 0.
-
 
68
 */
60
static inline int is_system_method(unative_t method)
69
static inline int is_system_method(unative_t method)
61
{
70
{
62
    if (method <= IPC_M_LAST_SYSTEM)
71
    if (method <= IPC_M_LAST_SYSTEM)
63
        return 1;
72
        return 1;
64
    return 0;
73
    return 0;
65
}
74
}
66
 
75
 
67
/** Return true if the message with this method is forwardable
76
/** Decide if the message with this method is forwardable.
68
 *
77
 *
69
 * - some system messages may be forwarded, for some of them
78
 * - some system messages may be forwarded, for some of them
70
 *   it is useless
79
 *   it is useless
-
 
80
 *
-
 
81
 * @param method    Method to be decided.
-
 
82
 *
-
 
83
 * @return      Return 1 if the method is forwardable.
-
 
84
 *          Otherwise return 0.
71
 */
85
 */
72
static inline int is_forwardable(unative_t method)
86
static inline int is_forwardable(unative_t method)
73
{
87
{
74
    if (method == IPC_M_PHONE_HUNGUP || method == IPC_M_AS_AREA_SEND ||
88
    if (method == IPC_M_PHONE_HUNGUP || method == IPC_M_AS_AREA_SEND ||
75
        method == IPC_M_AS_AREA_RECV)
89
        method == IPC_M_AS_AREA_RECV)
76
        return 0; /* This message is meant only for the receiver */
90
        return 0; /* This message is meant only for the receiver */
77
    return 1;
91
    return 1;
78
}
92
}
79
 
93
 
80
/****************************************************/
-
 
81
/* Functions that preprocess answer before sending
-
 
82
 * it to the recepient
-
 
83
 */
-
 
84
 
94
 
-
 
95
/***********************************************************************
-
 
96
 * Functions that preprocess answer before sending it to the recepient.
-
 
97
 ***********************************************************************/
-
 
98
 
85
/** Return true if the caller (ipc_answer) should save
99
/** Decide if the caller (e.g. ipc_answer()) should save the old call contents
86
 * the old call contents for answer_preprocess
100
 * for answer_preprocess().
-
 
101
 *
-
 
102
 * @param call      Call structure to be decided.
-
 
103
 *
-
 
104
 * @return      Return 1 if the old call contents should be saved.
-
 
105
 *          Return 0 otherwise.
87
 */
106
 */
88
static inline int answer_need_old(call_t *call)
107
static inline int answer_need_old(call_t *call)
89
{
108
{
90
    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
109
    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
91
        return 1;
110
        return 1;
Line 96... Line 115...
96
    if (IPC_GET_METHOD(call->data) == IPC_M_AS_AREA_RECV)
115
    if (IPC_GET_METHOD(call->data) == IPC_M_AS_AREA_RECV)
97
        return 1;
116
        return 1;
98
    return 0;
117
    return 0;
99
}
118
}
100
 
119
 
101
/** Interpret process answer as control information
120
/** Interpret process answer as control information.
102
 *
121
 *
103
 * This function is called directly after sys_ipc_answer
122
 * This function is called directly after sys_ipc_answer().
-
 
123
 *
-
 
124
 * @param answer    Call structure with the answer.
-
 
125
 * @param olddata   Saved data of the request.
-
 
126
 *
-
 
127
 * @return      Return 0 on success or an error code.
104
 */
128
 */
105
static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
129
static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
106
{
130
{
107
    int phoneid;
131
    int phoneid;
108
 
132
 
Line 129... Line 153...
129
            /* The connection was not accepted */
153
            /* The connection was not accepted */
130
            phone_dealloc(phoneid);
154
            phone_dealloc(phoneid);
131
        } else {
155
        } else {
132
            /* The connection was accepted */
156
            /* The connection was accepted */
133
            phone_connect(phoneid, &answer->sender->answerbox);
157
            phone_connect(phoneid, &answer->sender->answerbox);
134
            /* Set 'phone identification' as arg3 of response */
158
            /* Set 'phone hash' as arg3 of response */
135
            IPC_SET_ARG3(answer->data,
159
            IPC_SET_ARG3(answer->data,
136
                (unative_t) &TASK->phones[phoneid]);
160
                (unative_t) &TASK->phones[phoneid]);
137
        }
161
        }
138
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
162
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
139
        /* If the users accepted call, connect */
163
        /* If the users accepted call, connect */
Line 179... Line 203...
179
        }
203
        }
180
    }
204
    }
181
    return 0;
205
    return 0;
182
}
206
}
183
 
207
 
184
/** Called before the request is sent
208
/** Called before the request is sent.
-
 
209
 *
-
 
210
 * @param call      Call structure with the request.
185
 *
211
 *
186
 * @return 0 - no error, -1 - report error to user
212
 * @return      Return 0 on success, ELIMIT or EPERM on error.
187
 */
213
 */
188
static int request_preprocess(call_t *call)
214
static int request_preprocess(call_t *call)
189
{
215
{
190
    int newphid;
216
    int newphid;
191
    size_t size;
217
    size_t size;
Line 200... Line 226...
200
        call->flags |= IPC_CALL_CONN_ME_TO;
226
        call->flags |= IPC_CALL_CONN_ME_TO;
201
        call->priv = newphid;
227
        call->priv = newphid;
202
        break;
228
        break;
203
    case IPC_M_AS_AREA_SEND:
229
    case IPC_M_AS_AREA_SEND:
204
        size = as_get_size(IPC_GET_ARG1(call->data));
230
        size = as_get_size(IPC_GET_ARG1(call->data));
205
        if (!size) {
231
        if (!size)
206
            return EPERM;
232
            return EPERM;
207
        }
-
 
208
        IPC_SET_ARG2(call->data, size);
233
        IPC_SET_ARG2(call->data, size);
209
        break;
234
        break;
210
    default:
235
    default:
211
        break;
236
        break;
212
    }
237
    }
213
    return 0;
238
    return 0;
214
}
239
}
215
 
240
 
216
/****************************************************/
241
/*******************************************************************************
217
/* Functions called to process received call/answer
242
 * Functions called to process received call/answer before passing it to uspace.
218
 * before passing to uspace
243
 *******************************************************************************/
219
 */
-
 
220
 
244
 
221
/** Do basic kernel processing of received call answer */
245
/** Do basic kernel processing of received call answer.
-
 
246
 *
-
 
247
 * @param call      Call structure with the answer.
-
 
248
 */
222
static void process_answer(call_t *call)
249
static void process_answer(call_t *call)
223
{
250
{
224
    if (IPC_GET_RETVAL(call->data) == EHANGUP &&
251
    if (IPC_GET_RETVAL(call->data) == EHANGUP &&
225
        (call->flags & IPC_CALL_FORWARDED))
252
        (call->flags & IPC_CALL_FORWARDED))
226
        IPC_SET_RETVAL(call->data, EFORWARD);
253
        IPC_SET_RETVAL(call->data, EFORWARD);
Line 231... Line 258...
231
        else
258
        else
232
            IPC_SET_ARG3(call->data, call->priv);
259
            IPC_SET_ARG3(call->data, call->priv);
233
    }
260
    }
234
}
261
}
235
 
262
 
236
/** Do basic kernel processing of received call request
263
/** Do basic kernel processing of received call request.
237
 *
264
 *
-
 
265
 * @param box       Destination answerbox structure.
-
 
266
 * @param call      Call structure with the request.
-
 
267
 *
238
 * @return 0 - the call should be passed to userspace, 1 - ignore call
268
 * @return      Return 0 if the call should be passed to userspace.
-
 
269
 *          Return -1 if the call should be ignored.
239
 */
270
 */
240
static int process_request(answerbox_t *box, call_t *call)
271
static int process_request(answerbox_t *box, call_t *call)
241
{
272
{
242
    int phoneid;
273
    int phoneid;
243
 
274
 
Line 251... Line 282...
251
        IPC_SET_ARG3(call->data, phoneid);
282
        IPC_SET_ARG3(call->data, phoneid);
252
    }
283
    }
253
    return 0;
284
    return 0;
254
}
285
}
255
 
286
 
256
/** Send a call over IPC, wait for reply, return to user
287
/** Make a fast call over IPC, wait for reply and return to user.
-
 
288
 *
-
 
289
 * This function can handle only one argument of payload, but is faster than
-
 
290
 * the generic function (i.e. sys_ipc_call_sync()).
257
 *
291
 *
-
 
292
 * @param phoneid   Phone handle for the call.
-
 
293
 * @param method    Method of the call.
-
 
294
 * @param arg1      Service-defined payload argument.
-
 
295
 * @param data      Address of userspace structure where the reply call will
-
 
296
 *          be stored.
-
 
297
 *
258
 * @return Call identification, returns -1 on fatal error,
298
 * @return      Returns 0 on success.
259
           -2 on 'Too many async request, handle answers first
299
 *          Return ENOENT if there is no such phone handle.
260
 */
300
 */
261
unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
301
unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
262
    unative_t arg1, ipc_data_t *data)
302
    unative_t arg1, ipc_data_t *data)
263
{
303
{
264
    call_t call;
304
    call_t call;
Line 272... Line 312...
272
    IPC_SET_ARG1(call.data, arg1);
312
    IPC_SET_ARG1(call.data, arg1);
273
 
313
 
274
    if (!(res=request_preprocess(&call))) {
314
    if (!(res = request_preprocess(&call))) {
275
        ipc_call_sync(phone, &call);
315
        ipc_call_sync(phone, &call);
276
        process_answer(&call);
316
        process_answer(&call);
277
    } else
317
    } else {
278
        IPC_SET_RETVAL(call.data, res);
318
        IPC_SET_RETVAL(call.data, res);
-
 
319
    }
279
    STRUCT_TO_USPACE(&data->args, &call.data.args);
320
    STRUCT_TO_USPACE(&data->args, &call.data.args);
280
 
321
 
281
    return 0;
322
    return 0;
282
}
323
}
283
 
324
 
284
/** Synchronous IPC call allowing to send whole message */
325
/** Make a synchronous IPC call allowing to transmit the entire payload.
-
 
326
 *
-
 
327
 * @param phoneid   Phone handle for the call.
-
 
328
 * @param question  Userspace address of call data with the request.
-
 
329
 * @param reply     Userspace address of call data where to store the answer.
-
 
330
 *
-
 
331
 * @return      Zero on success or an error code.
-
 
332
 */
285
unative_t sys_ipc_call_sync(unative_t phoneid, ipc_data_t *question,
333
unative_t sys_ipc_call_sync(unative_t phoneid, ipc_data_t *question,
286
    ipc_data_t *reply)
334
    ipc_data_t *reply)
287
{
335
{
288
    call_t call;
336
    call_t call;
289
    phone_t *phone;
337
    phone_t *phone;
Line 309... Line 357...
309
        return rc;
357
        return rc;
310
 
358
 
311
    return 0;
359
    return 0;
312
}
360
}
313
 
361
 
314
/** Check that the task did not exceed allowed limit
362
/** Check that the task did not exceed the allowed limit of asynchronous calls.
315
 *
363
 *
316
 * @return 0 - Limit OK,   -1 - limit exceeded
364
 * @return      Return 0 if limit not reached or -1 if limit exceeded.
317
 */
365
 */
318
static int check_call_limit(void)
366
static int check_call_limit(void)
319
{
367
{
320
    if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
368
    if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
321
        atomic_dec(&TASK->active_calls);
369
        atomic_dec(&TASK->active_calls);
322
        return -1;
370
        return -1;
323
    }
371
    }
324
    return 0;
372
    return 0;
325
}
373
}
326
 
374
 
327
/** Send an asynchronous call over ipc
375
/** Make a fast asynchronous call over IPC.
328
 *
376
 *
-
 
377
 * This function can only handle two arguments of payload, but is faster than
-
 
378
 * the generic function sys_ipc_call_async().
-
 
379
 *
-
 
380
 * @param phoneid   Phone handle for the call.
-
 
381
 * @param method    Method of the call.
-
 
382
 * @param arg1      Service-defined payload argument.
-
 
383
 * @param arg2      Service-defined payload argument.
-
 
384
 *
-
 
385
 * @return      Return call hash on success.
329
 * @return Call identification, returns -1 on fatal error,
386
 *          Return IPC_CALLRET_FATAL in case of a fatal error and
-
 
387
 *          IPC_CALLRET_TEMPORARY if there are too many pending
330
           -2 on 'Too many async request, handle answers first
388
 *          asynchronous requests; answers should be handled first.
331
 */
389
 */
332
unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
390
unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
333
    unative_t arg1, unative_t arg2)
391
    unative_t arg1, unative_t arg2)
334
{
392
{
335
    call_t *call;
393
    call_t *call;
Line 353... Line 411...
353
        ipc_backsend_err(phone, call, res);
411
        ipc_backsend_err(phone, call, res);
354
 
412
 
355
    return (unative_t) call;
413
    return (unative_t) call;
356
}
414
}
357
 
415
 
358
/** Synchronous IPC call allowing to send whole message
416
/** Make an asynchronous IPC call allowing to transmit the entire payload.
-
 
417
 *
-
 
418
 * @param phoneid   Phone handle for the call.
-
 
419
 * @param data      Userspace address of call data with the request.
359
 *
420
 *
360
 * @return The same as sys_ipc_call_async
421
 * @return      See sys_ipc_call_async_fast().
361
 */
422
 */
362
unative_t sys_ipc_call_async(unative_t phoneid, ipc_data_t *data)
423
unative_t sys_ipc_call_async(unative_t phoneid, ipc_data_t *data)
363
{
424
{
364
    call_t *call;
425
    call_t *call;
365
    phone_t *phone;
426
    phone_t *phone;
Line 384... Line 445...
384
        ipc_backsend_err(phone, call, res);
445
        ipc_backsend_err(phone, call, res);
385
 
446
 
386
    return (unative_t) call;
447
    return (unative_t) call;
387
}
448
}
388
 
449
 
389
/** Forward received call to another destination
450
/** Forward a received call to another destination.
390
 *
451
 *
-
 
452
 * @param callid    Hash of the call to forward.
-
 
453
 * @param phoneid   Phone handle to use for forwarding.
-
 
454
 * @param method    New method to use for the forwarded call.
391
 * The arg1 and arg2 are changed in the forwarded message
455
 * @param arg1      New value of the first argument for the forwarded call.
-
 
456
 *
-
 
457
 * @return      Return 0 on succes, otherwise return an error code.
-
 
458
 *
-
 
459
 * In case the original method is a system method, ARG1 and ARG2 are overwritten
-
 
460
 * in the forwarded message with the new method and the new arg1, respectively.
-
 
461
 * Otherwise the METHOD and ARG1 are rewritten with the new method and arg1,
-
 
462
 * respectively.
392
 *
463
 *
393
 * Warning: If implementing non-fast version, make sure that
464
 * Warning: If implementing non-fast version, make sure that
394
 *          arg3 is not rewritten for certain system IPC
465
 *          ARG3 is not rewritten for certain system IPC
395
 */
466
 */
396
unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
467
unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
397
    unative_t method, unative_t arg1)
468
    unative_t method, unative_t arg1)
398
{
469
{
399
    call_t *call;
470
    call_t *call;
Line 432... Line 503...
432
    }
503
    }
433
 
504
 
434
    return ipc_forward(call, phone, &TASK->answerbox);
505
    return ipc_forward(call, phone, &TASK->answerbox);
435
}
506
}
436
 
507
 
437
/** Send IPC answer */
508
/** Answer an IPC call - fast version.
-
 
509
 *
-
 
510
 * This function can handle only two return arguments of payload, but is faster
-
 
511
 * than the generic sys_ipc_answer().
-
 
512
 *
-
 
513
 * @param callid    Hash of the call to be answered.
-
 
514
 * @param retval    Return value of the answer.
-
 
515
 * @param arg1      Service-defined return value.
-
 
516
 * @param arg2      Service-defined return value.
-
 
517
 *
-
 
518
 * @return      Return 0 on success, otherwise return an error code.   
-
 
519
 */
438
unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
520
unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
439
    unative_t arg1, unative_t arg2)
521
    unative_t arg1, unative_t arg2)
440
{
522
{
441
    call_t *call;
523
    call_t *call;
442
    ipc_data_t saved_data;
524
    ipc_data_t saved_data;
Line 463... Line 545...
463
 
545
 
464
    ipc_answer(&TASK->answerbox, call);
546
    ipc_answer(&TASK->answerbox, call);
465
    return rc;
547
    return rc;
466
}
548
}
467
 
549
 
468
/** Send IPC answer */
550
/** Answer an IPC call.
-
 
551
 *
-
 
552
 * @param callid    Hash of the call to be answered.
-
 
553
 * @param data      Userspace address of call data with the answer.
-
 
554
 *
-
 
555
 * @return      Return 0 on success, otherwise return an error code.
-
 
556
 */
469
unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data)
557
unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data)
470
{
558
{
471
    call_t *call;
559
    call_t *call;
472
    ipc_data_t saved_data;
560
    ipc_data_t saved_data;
473
    int saveddata = 0;
561
    int saveddata = 0;
Line 495... Line 583...
495
    ipc_answer(&TASK->answerbox, call);
583
    ipc_answer(&TASK->answerbox, call);
496
 
584
 
497
    return rc;
585
    return rc;
498
}
586
}
499
 
587
 
500
/** Hang up the phone
588
/** Hang up a phone.
501
 *
589
 *
-
 
590
 * @param       Phone handle of the phone to be hung up.
-
 
591
 *
-
 
592
 * @return      Return 0 on success or an error code.
502
 */
593
 */
503
unative_t sys_ipc_hangup(int phoneid)
594
unative_t sys_ipc_hangup(int phoneid)
504
{
595
{
505
    phone_t *phone;
596
    phone_t *phone;
506
 
597
 
Line 510... Line 601...
510
        return -1;
601
        return -1;
511
 
602
 
512
    return 0;
603
    return 0;
513
}
604
}
514
 
605
 
515
/** Wait for incoming ipc call or answer
606
/** Wait for an incoming IPC call or an answer.
516
 *
607
 *
517
 * @param calldata  Pointer to buffer where the call/answer data is stored.
608
 * @param calldata  Pointer to buffer where the call/answer data is stored.
518
 * @param usec      Timeout. See waitq_sleep_timeout() for explanation.
609
 * @param usec      Timeout. See waitq_sleep_timeout() for explanation.
519
 * @param flags     Select mode of sleep operation. See waitq_sleep_timeout()
610
 * @param flags     Select mode of sleep operation. See waitq_sleep_timeout()
520
 *          for explanation.
611
 *          for explanation.
521
 *
612
 *
522
 * @return Callid, if callid & 1, then the call is answer
613
 * @return      Hash of the call.
-
 
614
 *          If IPC_CALLID_NOTIFICATION bit is set in the hash, the
-
 
615
 *          call is a notification. IPC_CALLID_ANSWERED denotes an
-
 
616
 *          answer.
523
 */
617
 */
524
unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
618
unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
525
{
619
{
526
    call_t *call;
620
    call_t *call;
527
 
621
 
Line 571... Line 665...
571
        return 0;
665
        return 0;
572
    }
666
    }
573
    return (unative_t)call;
667
    return (unative_t)call;
574
}
668
}
575
 
669
 
576
/** Connect irq handler to task.
670
/** Connect an IRQ handler to a task.
577
 *
671
 *
578
 * @param inr IRQ number.
672
 * @param inr       IRQ number.
579
 * @param devno Device number.
673
 * @param devno     Device number.
580
 * @param method Method to be associated with the notification.
674
 * @param method    Method to be associated with the notification.
581
 * @param ucode Uspace pointer to the top-half pseudocode.
675
 * @param ucode     Uspace pointer to the top-half pseudocode.
Line 589... Line 683...
589
        return EPERM;
683
        return EPERM;
590
 
684
 
591
    return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
685
    return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
592
}
686
}
593
 
687
 
594
/** Disconnect irq handler from task.
688
/** Disconnect an IRQ handler from a task.
595
 *
689
 *
596
 * @param inr IRQ number.
690
 * @param inr       IRQ number.
597
 * @param devno Device number.
691
 * @param devno     Device number.
-
 
692
 *
-
 
693
 * @return      Zero on success or EPERM on error..
598
 */
694
 */
599
unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
695
unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
600
{
696
{
601
    if (!(cap_get(TASK) & CAP_IRQ_REG))
697
    if (!(cap_get(TASK) & CAP_IRQ_REG))
602
        return EPERM;
698
        return EPERM;