Subversion Repositories HelenOS

Rev

Rev 2071 | Rev 2359 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1027 palkovsky 1
/*
2071 jermar 2
 * Copyright (c) 2006 Ondrej Palkovsky
1027 palkovsky 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
1757 jermar 29
/** @addtogroup genericipc
1702 cejka 30
 * @{
31
 */
32
/** @file
33
 */
34
 
1027 palkovsky 35
#include <arch.h>
36
#include <proc/task.h>
1288 jermar 37
#include <proc/thread.h>
1027 palkovsky 38
#include <errno.h>
39
#include <memstr.h>
40
#include <debug.h>
41
#include <ipc/ipc.h>
42
#include <ipc/sysipc.h>
1281 palkovsky 43
#include <ipc/irq.h>
1072 palkovsky 44
#include <ipc/ipcrsc.h>
1258 palkovsky 45
#include <arch/interrupt.h>
1027 palkovsky 46
#include <print.h>
1288 jermar 47
#include <syscall/copy.h>
1297 jermar 48
#include <security/cap.h>
1329 palkovsky 49
#include <mm/as.h>
1875 jermar 50
#include <print.h>
1027 palkovsky 51
 
1084 palkovsky 52
#define GET_CHECK_PHONE(phone,phoneid,err) { \
53
      if (phoneid > IPC_MAX_PHONES) { err; } \
54
      phone = &TASK->phones[phoneid]; \
55
}
56
 
1090 palkovsky 57
#define STRUCT_TO_USPACE(dst,src) copy_to_uspace(dst,src,sizeof(*(src)))
1084 palkovsky 58
 
1040 palkovsky 59
/** Return true if the method is a system method */
1780 jermar 60
static inline int is_system_method(unative_t method)
1040 palkovsky 61
{
62
    if (method <= IPC_M_LAST_SYSTEM)
63
        return 1;
64
    return 0;
65
}
66
 
67
/** Return true if the message with this method is forwardable
68
 *
69
 * - some system messages may be forwarded, for some of them
70
 *   it is useless
71
 */
1780 jermar 72
static inline int is_forwardable(unative_t method)
1040 palkovsky 73
{
1428 palkovsky 74
    if (method == IPC_M_PHONE_HUNGUP || method == IPC_M_AS_AREA_SEND \
75
        || method == IPC_M_AS_AREA_RECV)
1086 palkovsky 76
        return 0; /* This message is meant only for the receiver */
1040 palkovsky 77
    return 1;
78
}
79
 
1027 palkovsky 80
/****************************************************/
81
/* Functions that preprocess answer before sending
82
 * it to the recepient
83
 */
84
 
85
/** Return true if the caller (ipc_answer) should save
1088 palkovsky 86
 * the old call contents for answer_preprocess
1027 palkovsky 87
 */
1088 palkovsky 88
static inline int answer_need_old(call_t *call)
1027 palkovsky 89
{
1086 palkovsky 90
    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
1027 palkovsky 91
        return 1;
1086 palkovsky 92
    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_ME_TO)
1060 palkovsky 93
        return 1;
1359 jermar 94
    if (IPC_GET_METHOD(call->data) == IPC_M_AS_AREA_SEND)
1329 palkovsky 95
        return 1;
1428 palkovsky 96
    if (IPC_GET_METHOD(call->data) == IPC_M_AS_AREA_RECV)
97
        return 1;
1027 palkovsky 98
    return 0;
99
}
100
 
1428 palkovsky 101
/** Interpret process answer as control information
102
 *
103
 * This function is called directly after sys_ipc_answer
104
 */
1329 palkovsky 105
static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata)
1027 palkovsky 106
{
107
    int phoneid;
108
 
1088 palkovsky 109
    if (IPC_GET_RETVAL(answer->data) == EHANGUP) {
1141 palkovsky 110
        /* In case of forward, hangup the forwared phone,
111
         * not the originator
112
         */
113
        spinlock_lock(&answer->data.phone->lock);
114
        spinlock_lock(&TASK->answerbox.lock);
1568 palkovsky 115
        if (answer->data.phone->state == IPC_PHONE_CONNECTED) {
1573 palkovsky 116
            list_remove(&answer->data.phone->link);
1568 palkovsky 117
            answer->data.phone->state = IPC_PHONE_SLAMMED;
1141 palkovsky 118
        }
119
        spinlock_unlock(&TASK->answerbox.lock);
120
        spinlock_unlock(&answer->data.phone->lock);
1088 palkovsky 121
    }
122
 
123
    if (!olddata)
1329 palkovsky 124
        return 0;
1088 palkovsky 125
 
1086 palkovsky 126
    if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
1040 palkovsky 127
        phoneid = IPC_GET_ARG3(*olddata);
1027 palkovsky 128
        if (IPC_GET_RETVAL(answer->data)) {
129
            /* The connection was not accepted */
130
            phone_dealloc(phoneid);
1040 palkovsky 131
        } else {
1090 palkovsky 132
            /* The connection was accepted */
1040 palkovsky 133
            phone_connect(phoneid,&answer->sender->answerbox);
1090 palkovsky 134
            /* Set 'phone identification' as arg3 of response */
1780 jermar 135
            IPC_SET_ARG3(answer->data, (unative_t)&TASK->phones[phoneid]);
1027 palkovsky 136
        }
1086 palkovsky 137
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
1060 palkovsky 138
        /* If the users accepted call, connect */
139
        if (!IPC_GET_RETVAL(answer->data)) {
140
            ipc_phone_connect((phone_t *)IPC_GET_ARG3(*olddata),
141
                      &TASK->answerbox);
142
        }
1359 jermar 143
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_AS_AREA_SEND) {
144
        if (!IPC_GET_RETVAL(answer->data)) { /* Accepted, handle as_area receipt */
1413 jermar 145
            ipl_t ipl;
1461 palkovsky 146
            int rc;
1413 jermar 147
            as_t *as;
148
 
149
            ipl = interrupts_disable();
150
            spinlock_lock(&answer->sender->lock);
151
            as = answer->sender->as;
152
            spinlock_unlock(&answer->sender->lock);
153
            interrupts_restore(ipl);
154
 
1461 palkovsky 155
            rc = as_area_share(as, IPC_GET_ARG1(*olddata), IPC_GET_ARG2(*olddata),
156
                       AS, IPC_GET_ARG1(answer->data), IPC_GET_ARG3(*olddata));
157
            IPC_SET_RETVAL(answer->data, rc);
158
            return rc;
1329 palkovsky 159
        }
1428 palkovsky 160
    } else if (IPC_GET_METHOD(*olddata) == IPC_M_AS_AREA_RECV) {
161
        if (!IPC_GET_RETVAL(answer->data)) {
162
            ipl_t ipl;
163
            as_t *as;
1434 palkovsky 164
            int rc;
1428 palkovsky 165
 
166
            ipl = interrupts_disable();
167
            spinlock_lock(&answer->sender->lock);
168
            as = answer->sender->as;
169
            spinlock_unlock(&answer->sender->lock);
170
            interrupts_restore(ipl);
171
 
1434 palkovsky 172
            rc = as_area_share(AS, IPC_GET_ARG1(answer->data), IPC_GET_ARG2(*olddata),
1461 palkovsky 173
                       as, IPC_GET_ARG1(*olddata), IPC_GET_ARG2(answer->data));
1434 palkovsky 174
            IPC_SET_RETVAL(answer->data, rc);
1428 palkovsky 175
        }
1027 palkovsky 176
    }
1329 palkovsky 177
    return 0;
1027 palkovsky 178
}
179
 
1090 palkovsky 180
/** Called before the request is sent
181
 *
182
 * @return 0 - no error, -1 - report error to user
183
 */
184
static int request_preprocess(call_t *call)
185
{
186
    int newphid;
1329 palkovsky 187
    size_t size;
1090 palkovsky 188
 
189
    switch (IPC_GET_METHOD(call->data)) {
190
    case IPC_M_CONNECT_ME_TO:
191
        newphid = phone_alloc();
192
        if (newphid < 0)
193
            return ELIMIT;
194
        /* Set arg3 for server */
1780 jermar 195
        IPC_SET_ARG3(call->data, (unative_t)&TASK->phones[newphid]);
1090 palkovsky 196
        call->flags |= IPC_CALL_CONN_ME_TO;
2098 decky 197
        call->priv = newphid;
1090 palkovsky 198
        break;
1359 jermar 199
    case IPC_M_AS_AREA_SEND:
1417 jermar 200
        size = as_get_size(IPC_GET_ARG1(call->data));
1329 palkovsky 201
        if (!size) {
202
            return EPERM;
203
        }
1417 jermar 204
        IPC_SET_ARG2(call->data, size);
1329 palkovsky 205
        break;
1090 palkovsky 206
    default:
207
        break;
208
    }
209
    return 0;
210
}
211
 
1027 palkovsky 212
/****************************************************/
213
/* Functions called to process received call/answer
214
 * before passing to uspace
215
 */
216
 
217
/** Do basic kernel processing of received call answer */
1090 palkovsky 218
static void process_answer(call_t *call)
1027 palkovsky 219
{
1088 palkovsky 220
    if (IPC_GET_RETVAL(call->data) == EHANGUP && \
221
        call->flags & IPC_CALL_FORWARDED)
222
        IPC_SET_RETVAL(call->data, EFORWARD);
1090 palkovsky 223
 
224
    if (call->flags & IPC_CALL_CONN_ME_TO) {
225
        if (IPC_GET_RETVAL(call->data))
2098 decky 226
            phone_dealloc(call->priv);
1090 palkovsky 227
        else
2098 decky 228
            IPC_SET_ARG3(call->data, call->priv);
1090 palkovsky 229
    }
1027 palkovsky 230
}
231
 
232
/** Do basic kernel processing of received call request
233
 *
234
 * @return 0 - the call should be passed to userspace, 1 - ignore call
235
 */
236
static int process_request(answerbox_t *box,call_t *call)
237
{
238
    int phoneid;
239
 
1086 palkovsky 240
    if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
1040 palkovsky 241
        phoneid = phone_alloc();
1027 palkovsky 242
        if (phoneid < 0) { /* Failed to allocate phone */
243
            IPC_SET_RETVAL(call->data, ELIMIT);
244
            ipc_answer(box,call);
245
            return -1;
246
        }
247
        IPC_SET_ARG3(call->data, phoneid);
248
    }
249
    return 0;
250
}
251
 
252
/** Send a call over IPC, wait for reply, return to user
253
 *
254
 * @return Call identification, returns -1 on fatal error,
255
           -2 on 'Too many async request, handle answers first
256
 */
1780 jermar 257
unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
258
                unative_t arg1, ipc_data_t *data)
1027 palkovsky 259
{
260
    call_t call;
261
    phone_t *phone;
1090 palkovsky 262
    int res;
1027 palkovsky 263
 
1084 palkovsky 264
    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
1027 palkovsky 265
 
1084 palkovsky 266
    ipc_call_static_init(&call);
1027 palkovsky 267
    IPC_SET_METHOD(call.data, method);
268
    IPC_SET_ARG1(call.data, arg1);
269
 
1090 palkovsky 270
    if (!(res=request_preprocess(&call))) {
271
        ipc_call_sync(phone, &call);
272
        process_answer(&call);
273
    } else
274
        IPC_SET_RETVAL(call.data, res);
1086 palkovsky 275
    STRUCT_TO_USPACE(&data->args, &call.data.args);
1027 palkovsky 276
 
277
    return 0;
278
}
279
 
280
/** Synchronous IPC call allowing to send whole message */
1780 jermar 281
unative_t sys_ipc_call_sync(unative_t phoneid, ipc_data_t *question,
1086 palkovsky 282
               ipc_data_t *reply)
1027 palkovsky 283
{
284
    call_t call;
285
    phone_t *phone;
1090 palkovsky 286
    int res;
1288 jermar 287
    int rc;
1027 palkovsky 288
 
1084 palkovsky 289
    ipc_call_static_init(&call);
1288 jermar 290
    rc = copy_from_uspace(&call.data.args, &question->args, sizeof(call.data.args));
291
    if (rc != 0)
1780 jermar 292
        return (unative_t) rc;
1040 palkovsky 293
 
1084 palkovsky 294
    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
1072 palkovsky 295
 
1090 palkovsky 296
    if (!(res=request_preprocess(&call))) {
297
        ipc_call_sync(phone, &call);
298
        process_answer(&call);
299
    } else
300
        IPC_SET_RETVAL(call.data, res);
1027 palkovsky 301
 
1288 jermar 302
    rc = STRUCT_TO_USPACE(&reply->args, &call.data.args);
303
    if (rc != 0)
304
        return rc;
1027 palkovsky 305
 
306
    return 0;
307
}
308
 
309
/** Check that the task did not exceed allowed limit
310
 *
311
 * @return 0 - Limit OK,   -1 - limit exceeded
312
 */
313
static int check_call_limit(void)
314
{
315
    if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
316
        atomic_dec(&TASK->active_calls);
317
        return -1;
318
    }
319
    return 0;
320
}
321
 
322
/** Send an asynchronous call over ipc
323
 *
324
 * @return Call identification, returns -1 on fatal error,
325
           -2 on 'Too many async request, handle answers first
326
 */
1780 jermar 327
unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
328
                 unative_t arg1, unative_t arg2)
1027 palkovsky 329
{
330
    call_t *call;
331
    phone_t *phone;
1090 palkovsky 332
    int res;
1027 palkovsky 333
 
334
    if (check_call_limit())
335
        return IPC_CALLRET_TEMPORARY;
336
 
1090 palkovsky 337
    GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
1072 palkovsky 338
 
1258 palkovsky 339
    call = ipc_call_alloc(0);
1027 palkovsky 340
    IPC_SET_METHOD(call->data, method);
341
    IPC_SET_ARG1(call->data, arg1);
342
    IPC_SET_ARG2(call->data, arg2);
1669 palkovsky 343
    IPC_SET_ARG3(call->data, 0);
1027 palkovsky 344
 
1090 palkovsky 345
    if (!(res=request_preprocess(call)))
346
        ipc_call(phone, call);
347
    else
348
        ipc_backsend_err(phone, call, res);
1027 palkovsky 349
 
1780 jermar 350
    return (unative_t) call;
1027 palkovsky 351
}
352
 
353
/** Synchronous IPC call allowing to send whole message
354
 *
355
 * @return The same as sys_ipc_call_async
356
 */
1780 jermar 357
unative_t sys_ipc_call_async(unative_t phoneid, ipc_data_t *data)
1027 palkovsky 358
{
359
    call_t *call;
360
    phone_t *phone;
1090 palkovsky 361
    int res;
1288 jermar 362
    int rc;
1027 palkovsky 363
 
1072 palkovsky 364
    if (check_call_limit())
365
        return IPC_CALLRET_TEMPORARY;
366
 
1090 palkovsky 367
    GET_CHECK_PHONE(phone, phoneid, return IPC_CALLRET_FATAL);
1027 palkovsky 368
 
1258 palkovsky 369
    call = ipc_call_alloc(0);
1288 jermar 370
    rc = copy_from_uspace(&call->data.args, &data->args, sizeof(call->data.args));
1293 palkovsky 371
    if (rc != 0) {
372
        ipc_call_free(call);
1780 jermar 373
        return (unative_t) rc;
1293 palkovsky 374
    }
1090 palkovsky 375
    if (!(res=request_preprocess(call)))
376
        ipc_call(phone, call);
377
    else
378
        ipc_backsend_err(phone, call, res);
1040 palkovsky 379
 
1780 jermar 380
    return (unative_t) call;
1027 palkovsky 381
}
382
 
1040 palkovsky 383
/** Forward received call to another destination
384
 *
385
 * The arg1 and arg2 are changed in the forwarded message
1060 palkovsky 386
 *
387
 * Warning: If implementing non-fast version, make sure that
388
 *          arg3 is not rewritten for certain system IPC
1040 palkovsky 389
 */
1780 jermar 390
unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
391
                  unative_t method, unative_t arg1)
1040 palkovsky 392
{
393
    call_t *call;
394
    phone_t *phone;
395
 
396
    call = get_call(callid);
397
    if (!call)
398
        return ENOENT;
399
 
1088 palkovsky 400
    call->flags |= IPC_CALL_FORWARDED;
401
 
1084 palkovsky 402
    GET_CHECK_PHONE(phone, phoneid, {
1040 palkovsky 403
        IPC_SET_RETVAL(call->data, EFORWARD);
404
        ipc_answer(&TASK->answerbox, call);
405
        return ENOENT;
1084 palkovsky 406
    });    
1040 palkovsky 407
 
408
    if (!is_forwardable(IPC_GET_METHOD(call->data))) {
409
        IPC_SET_RETVAL(call->data, EFORWARD);
410
        ipc_answer(&TASK->answerbox, call);
411
        return EPERM;
412
    }
413
 
414
    /* Userspace is not allowed to change method of system methods
415
     * on forward, allow changing ARG1 and ARG2 by means of method and arg1
416
     */
417
    if (is_system_method(IPC_GET_METHOD(call->data))) {
1090 palkovsky 418
        if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
419
            phone_dealloc(IPC_GET_ARG3(call->data));
420
 
1040 palkovsky 421
        IPC_SET_ARG1(call->data, method);
422
        IPC_SET_ARG2(call->data, arg1);
423
    } else {
424
        IPC_SET_METHOD(call->data, method);
425
        IPC_SET_ARG1(call->data, arg1);
426
    }
427
 
1088 palkovsky 428
    return ipc_forward(call, phone, &TASK->answerbox);
1040 palkovsky 429
}
430
 
1027 palkovsky 431
/** Send IPC answer */
1780 jermar 432
unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
433
                 unative_t arg1, unative_t arg2)
1027 palkovsky 434
{
435
    call_t *call;
1040 palkovsky 436
    ipc_data_t saved_data;
1088 palkovsky 437
    int saveddata = 0;
1329 palkovsky 438
    int rc;
1027 palkovsky 439
 
1346 palkovsky 440
    /* Do not answer notification callids */
441
    if (callid & IPC_CALLID_NOTIFICATION)
442
        return 0;
443
 
1040 palkovsky 444
    call = get_call(callid);
445
    if (!call)
446
        return ENOENT;
1027 palkovsky 447
 
1088 palkovsky 448
    if (answer_need_old(call)) {
1040 palkovsky 449
        memcpy(&saved_data, &call->data, sizeof(call->data));
1088 palkovsky 450
        saveddata = 1;
1027 palkovsky 451
    }
452
 
453
    IPC_SET_RETVAL(call->data, retval);
454
    IPC_SET_ARG1(call->data, arg1);
455
    IPC_SET_ARG2(call->data, arg2);
1329 palkovsky 456
    rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
1040 palkovsky 457
 
1027 palkovsky 458
    ipc_answer(&TASK->answerbox, call);
1329 palkovsky 459
    return rc;
1027 palkovsky 460
}
461
 
462
/** Send IPC answer */
1780 jermar 463
unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data)
1027 palkovsky 464
{
465
    call_t *call;
1040 palkovsky 466
    ipc_data_t saved_data;
1088 palkovsky 467
    int saveddata = 0;
1288 jermar 468
    int rc;
1027 palkovsky 469
 
1346 palkovsky 470
    /* Do not answer notification callids */
471
    if (callid & IPC_CALLID_NOTIFICATION)
472
        return 0;
473
 
1040 palkovsky 474
    call = get_call(callid);
475
    if (!call)
476
        return ENOENT;
1027 palkovsky 477
 
1088 palkovsky 478
    if (answer_need_old(call)) {
1040 palkovsky 479
        memcpy(&saved_data, &call->data, sizeof(call->data));
1088 palkovsky 480
        saveddata = 1;
1027 palkovsky 481
    }
1288 jermar 482
    rc = copy_from_uspace(&call->data.args, &data->args,
1086 palkovsky 483
             sizeof(call->data.args));
1288 jermar 484
    if (rc != 0)
485
        return rc;
1027 palkovsky 486
 
1329 palkovsky 487
    rc = answer_preprocess(call, saveddata ? &saved_data : NULL);
1027 palkovsky 488
 
489
    ipc_answer(&TASK->answerbox, call);
490
 
1329 palkovsky 491
    return rc;
1027 palkovsky 492
}
493
 
1086 palkovsky 494
/** Hang up the phone
495
 *
496
 */
1780 jermar 497
unative_t sys_ipc_hangup(int phoneid)
1086 palkovsky 498
{
499
    phone_t *phone;
500
 
501
    GET_CHECK_PHONE(phone, phoneid, return ENOENT);
502
 
1591 palkovsky 503
    if (ipc_phone_hangup(phone))
1086 palkovsky 504
        return -1;
505
 
506
    return 0;
507
}
508
 
1027 palkovsky 509
/** Wait for incoming ipc call or answer
510
 *
1086 palkovsky 511
 * @param calldata Pointer to buffer where the call/answer data is stored
1364 jermar 512
 * @param usec Timeout. See waitq_sleep_timeout() for explanation.
1502 jermar 513
 * @param flags Select mode of sleep operation. See waitq_sleep_timeout() for explanation.
1364 jermar 514
 *
1027 palkovsky 515
 * @return Callid, if callid & 1, then the call is answer
516
 */
1780 jermar 517
unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
1027 palkovsky 518
{
519
    call_t *call;
520
 
521
restart:   
1502 jermar 522
    call = ipc_wait_for_call(&TASK->answerbox, usec, flags | SYNCH_FLAGS_INTERRUPTIBLE);
1088 palkovsky 523
    if (!call)
524
        return 0;
1027 palkovsky 525
 
1258 palkovsky 526
    if (call->flags & IPC_CALL_NOTIF) {
527
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
1693 palkovsky 528
 
529
        /* Set in_phone_hash to the interrupt counter */
2098 decky 530
        call->data.phone = (void *) call->priv;
1693 palkovsky 531
 
532
        STRUCT_TO_USPACE(calldata, &call->data);
533
 
1258 palkovsky 534
        ipc_call_free(call);
535
 
1780 jermar 536
        return ((unative_t)call) | IPC_CALLID_NOTIFICATION;
1258 palkovsky 537
    }
538
 
1027 palkovsky 539
    if (call->flags & IPC_CALL_ANSWERED) {
1090 palkovsky 540
        process_answer(call);
1027 palkovsky 541
 
1086 palkovsky 542
        ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
543
 
1027 palkovsky 544
        atomic_dec(&TASK->active_calls);
1086 palkovsky 545
 
546
        if (call->flags & IPC_CALL_DISCARD_ANSWER) {
547
            ipc_call_free(call);
548
            goto restart;
549
        }
550
 
551
        STRUCT_TO_USPACE(&calldata->args, &call->data.args);
1027 palkovsky 552
        ipc_call_free(call);
553
 
1780 jermar 554
        return ((unative_t)call) | IPC_CALLID_ANSWERED;
1027 palkovsky 555
    }
1086 palkovsky 556
 
1027 palkovsky 557
    if (process_request(&TASK->answerbox, call))
558
        goto restart;
1086 palkovsky 559
 
1090 palkovsky 560
    /* Include phone address('id') of the caller in the request,
561
     * copy whole call->data, not only call->data.args */
1396 palkovsky 562
    if (STRUCT_TO_USPACE(calldata, &call->data)) {
563
        return 0;
564
    }
1780 jermar 565
    return (unative_t)call;
1027 palkovsky 566
}
1258 palkovsky 567
 
1923 jermar 568
/** Connect irq handler to task.
569
 *
570
 * @param inr IRQ number.
571
 * @param devno Device number.
572
 * @param method Method to be associated with the notification.
573
 * @param ucode Uspace pointer to the top-half pseudocode.
574
 *
575
 * @return EPERM or a return code returned by ipc_irq_register().
576
 */
577
unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method, irq_code_t *ucode)
1258 palkovsky 578
{
1297 jermar 579
    if (!(cap_get(TASK) & CAP_IRQ_REG))
580
        return EPERM;
581
 
1923 jermar 582
    return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
1258 palkovsky 583
}
584
 
1923 jermar 585
/** Disconnect irq handler from task.
586
 *
587
 * @param inr IRQ number.
588
 * @param devno Device number.
589
 */
590
unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
1258 palkovsky 591
{
1297 jermar 592
    if (!(cap_get(TASK) & CAP_IRQ_REG))
593
        return EPERM;
594
 
1923 jermar 595
    ipc_irq_unregister(&TASK->answerbox, inr, devno);
1258 palkovsky 596
 
597
    return 0;
598
}
1702 cejka 599
 
1757 jermar 600
/** @}
1702 cejka 601
 */