WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/structures/packet/packet_server.c


/*
 * Copyright (c) 2009 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup packet
 *  @{
 */
 
/** @file
 *  Packet server implementation.
 */
 
#include <align.h>
#include <async.h>
#include <errno.h>
#include <futex.h>
//#include <stdio.h>
#include <unistd.h>
 
#include <ipc/ipc.h>
#include <sys/mman.h>
 
#include "../../err.h"
#include "../../messages.h"
 
#include "packet.h"
#include "packet_client.h"
#include "packet_header.h"
#include "packet_messages.h"
#include "packet_server.h"
 
#define FREE_QUEUES_COUNT   7
 
/** The default address length reserved for new packets.
 */
#define DEFAULT_ADDR_LEN    32
 
/** The default prefix reserved for new packets.
 */
#define DEFAULT_PREFIX      0
 
/** The default suffix reserved for new packets.
 */
#define DEFAULT_SUFFIX      0
 
/** Packet server global data.
 */
static struct{
    /** Safety lock.
     */
    futex_t lock;
    /** Free packet queues.
     */
    packet_t free[ FREE_QUEUES_COUNT ];
    /** Packet length upper bounds of the free packet queues.
     *  The maximal lengths of packets in each queue in the ascending order.
     *  The last queue is not limited.
     */
    size_t sizes[ FREE_QUEUES_COUNT ];
    /** Total packets allocated.
     */
    unsigned int count;
} ps_globals = {
    { 1 },
    { NULL, NULL, NULL, NULL, NULL, NULL, NULL },
    { PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64 },
    0
};
 
/** Returns the packet of dimensions at least as given.
 *  Tries to reuse free packets first.
 *  Creates a&nbsp;new packet aligned to the memory page size if none available.
 *  Locks the global data during its processing.
 *  @param addr_len The source and destination addresses maximal length in bytes. Input parameter.
 *  @param max_prefix The maximal prefix length in bytes. Input parameter.
 *  @param max_content The maximal content length in bytes. Input parameter.
 *  @param max_suffix The maximal suffix length in bytes. Input parameter.
 *  @returns The packet of dimensions at least as given.
 *  @returns NULL if there is not enough memory left.
 */
packet_t    packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
 
/** Releases the packet queue.
 *  @param packet_id The first packet identifier. Input parameter.
 *  @returns EOK on success.
 *  @returns ENOENT if there is no such packet.
 */
int packet_release_wrapper( packet_id_t packet_id );
 
/** Releases the packet and returns it to the appropriate free packet queue.
 *  Should be used only when the global data are locked.
 *  @param packet The packet to be released. Input parameter.
 */
void packet_release( packet_t packet );
 
/** Creates a&nbsp;new packet of dimensions at least as given.
 *  Should be used only when the global data are locked.
 *  @param length The total length of the packet, including the header, the addresses and the data of the packet. Input parameter.
 *  @param addr_len The source and destination addresses maximal length in bytes. Input parameter.
 *  @param max_prefix The maximal prefix length in bytes. Input parameter.
 *  @param max_content The maximal content length in bytes. Input parameter.
 *  @param max_suffix The maximal suffix length in bytes. Input parameter.
 *  @returns The packet of dimensions at least as given.
 *  @returns NULL if there is not enough memory left.
 */
packet_t    packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
 
/** Clears and initializes the packet according to the given dimensions.
 *  @param packet The packet to be initialized. Input parameter.
 *  @param addr_len The source and destination addresses maximal length in bytes. Input parameter.
 *  @param max_prefix The maximal prefix length in bytes. Input parameter.
 *  @param max_content The maximal content length in bytes. Input parameter.
 *  @param max_suffix The maximal suffix length in bytes. Input parameter.
 */
void    packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
 
/** Shares the packet memory block.
 *  @param packet The packet to be shared.
 *  @returns EOK on success.
 *  @returns EINVAL if the packet is not valid.
 *  @returns EINVAL if the calling module does not accept the memory.
 *  @returns ENOMEM if the desired and actual sizes differ.
 *  @returns Other error codes as defined for the ipc_share_in_finalize() function.
 */
int packet_reply( const packet_t packet );
 
int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){
    if( ! packet ) return EINVAL;
    * packet = pm_find( packet_id );
    return ( * packet ) ? EOK : ENOENT;
}
 
packet_t packet_get_4( int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix ){
    return packet_get( addr_len, max_prefix, max_content, max_suffix );
}
 
packet_t packet_get_1( int phone, size_t content ){
    return packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX );
}
 
void pq_release( int phone, packet_id_t packet_id ){
    ( void ) packet_release_wrapper( packet_id );
}
 
int packet_server_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    packet_t packet;
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case IPC_M_PHONE_HUNGUP:
            return EOK;
        case NET_PACKET_CREATE_1:
            packet = packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT( call ), DEFAULT_SUFFIX );
            if( ! packet ) return ENOMEM;
            * answer_count = 2;
            IPC_SET_ARG1( * answer, packet->packet_id );
            IPC_SET_ARG2( * answer, packet->length );
            return EOK;
        case NET_PACKET_CREATE_4:
            packet = packet_get( IPC_GET_ADDR_LEN( call ), IPC_GET_PREFIX( call ), IPC_GET_CONTENT( call ), IPC_GET_SUFFIX( call ));
            if( ! packet ) return ENOMEM;
            * answer_count = 2;
            IPC_SET_ARG1( * answer, packet->packet_id );
            IPC_SET_ARG2( * answer, packet->length );
            return EOK;
        case NET_PACKET_GET:
            packet = pm_find( IPC_GET_ID( call ));
            if( ! packet_is_valid( packet )) return ENOENT;
            return packet_reply( packet );
        case NET_PACKET_GET_SIZE:
            packet = pm_find( IPC_GET_ID( call ));
            if( ! packet_is_valid( packet )) return ENOENT;
 
            IPC_SET_ARG1( * answer, packet->length );
            * answer_count = 1;
            return EOK;
        case NET_PACKET_RELEASE:
            return packet_release_wrapper( IPC_GET_ID( call ));
    }
    return ENOTSUP;
}
 
int packet_release_wrapper( packet_id_t packet_id ){
    packet_t    packet;
 
    packet = pm_find( packet_id );
    if( ! packet_is_valid( packet )) return ENOENT;
    futex_down( & ps_globals.lock );
    pq_destroy( packet, packet_release );
    futex_up( & ps_globals.lock );
    return EOK;
}
 
void packet_release( packet_t packet ){
    int index;
 
    for( index = 0; ( index < FREE_QUEUES_COUNT - 1 ) && ( packet->length > ps_globals.sizes[ index ] ); ++ index );
    ps_globals.free[ index ] = pq_add( ps_globals.free[ index ], packet, packet->length, packet->length );
}
 
packet_t packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
    int index;
    packet_t packet;
    size_t length;
 
    length = ALIGN_UP( sizeof( struct packet ) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE );
    futex_down( & ps_globals.lock );
    for( index = 0; index < FREE_QUEUES_COUNT - 1; ++ index ){
        if( length <= ps_globals.sizes[ index ] ){
            packet = ps_globals.free[ index ];
            while( packet_is_valid( packet ) && ( packet->length < length )){
                packet = pm_find( packet->next );
            }
            if( packet_is_valid( packet )){
                if( packet == ps_globals.free[ index ] ){
                    ps_globals.free[ index ] = pq_detach( packet );
                }else{
                    pq_detach( packet );
                }
                packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
                futex_up( & ps_globals.lock );
                return packet;
            }
        }
    }
    packet = packet_create( length, addr_len, max_prefix, max_content, max_suffix );
    futex_up( & ps_globals.lock );
    return packet;
}
 
packet_t packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
    ERROR_DECLARE;
 
    packet_t    packet;
 
    // already locked
    packet = ( packet_t ) mmap( NULL, length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 );
    if( packet == MAP_FAILED ) return NULL;
    ++ ps_globals.count;
    packet->packet_id = ps_globals.count;
    packet->length = length;
    packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
    packet->magic_value = PACKET_MAGIC_VALUE;
    if( ERROR_OCCURRED( pm_add( packet ))){
        munmap( packet, packet->length );
        return NULL;
    }
 
    return packet;
}
 
void packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
 
 
    // clear the packet content
 
    bzero((( void * ) packet ) + sizeof( struct packet ), packet->length - sizeof( struct packet ));
 
 
    // clear the packet header
    packet->order = 0;
    packet->metric = 0;
    packet->previous = 0;
    packet->next = 0;
    packet->addr_len = 0;
    packet->src_addr = sizeof( struct packet );
    packet->dest_addr = packet->src_addr + addr_len;
    packet->max_prefix = max_prefix;
    packet->max_content = max_content;
    packet->data_start = packet->dest_addr + addr_len + packet->max_prefix;
    packet->data_end = packet->data_start;
}
 
int packet_reply( const packet_t packet ){
    ipc_callid_t    callid;
    size_t          size;
 
    if( ! packet_is_valid( packet )) return EINVAL;
    if( ipc_share_in_receive( & callid, & size ) <= 0 ) return EINVAL;
    if( size != packet->length ) return ENOMEM;
    return ipc_share_in_finalize( callid, packet, PROTO_READ | PROTO_WRITE );
}
 
/** @}
 */
 

Rev 4395	Rev 4505
1	/*	1	/*
2	* Copyright (c) 2009 Lukas Mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup packet	29	/** @addtogroup packet
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* Packet server implementation.	34	* Packet server implementation.
35	*/	35	*/
36		36
37	#include <align.h>	37	#include <align.h>
38	#include <async.h>	38	#include <async.h>
39	#include <errno.h>	39	#include <errno.h>
40	#include <futex.h>	40	#include <futex.h>
41	//#include <stdio.h>	41	//#include <stdio.h>
42	#include <unistd.h>	42	#include <unistd.h>
43		43
44	#include <ipc/ipc.h>	44	#include <ipc/ipc.h>
45	#include <sys/mman.h>	45	#include <sys/mman.h>
46		46
47	#include "../../err.h"	47	#include "../../err.h"
48	#include "../../messages.h"	48	#include "../../messages.h"
49		49
50	#include "packet.h"	50	#include "packet.h"
51	#include "packet_client.h"	51	#include "packet_client.h"
52	#include "packet_header.h"	52	#include "packet_header.h"
53	#include "packet_messages.h"	53	#include "packet_messages.h"
54	#include "packet_server.h"	54	#include "packet_server.h"
55		55
56	#define FREE_QUEUES_COUNT 7	56	#define FREE_QUEUES_COUNT 7
57		57
58	/** The default address length reserved for new packets.	58	/** The default address length reserved for new packets.
59	*/	59	*/
60	#define DEFAULT_ADDR_LEN 32	60	#define DEFAULT_ADDR_LEN 32
61		61
62	/** The default prefix reserved for new packets.	62	/** The default prefix reserved for new packets.
63	*/	63	*/
64	#define DEFAULT_PREFIX 0	64	#define DEFAULT_PREFIX 0
65		65
66	/** The default suffix reserved for new packets.	66	/** The default suffix reserved for new packets.
67	*/	67	*/
68	#define DEFAULT_SUFFIX 0	68	#define DEFAULT_SUFFIX 0
69		69
70	/** Packet server global data.	70	/** Packet server global data.
71	*/	71	*/
72	static struct{	72	static struct{
73	/** Safety lock.	73	/** Safety lock.
74	*/	74	*/
75	futex_t lock;	75	futex_t lock;
76	/** Free packet queues.	76	/** Free packet queues.
77	*/	77	*/
78	packet_t free[ FREE_QUEUES_COUNT ];	78	packet_t free[ FREE_QUEUES_COUNT ];
79	/** Packet length upper bounds of the free packet queues.	79	/** Packet length upper bounds of the free packet queues.
80	* The maximal lengths of packets in each queue in the ascending order.	80	* The maximal lengths of packets in each queue in the ascending order.
81	* The last queue is not limited.	81	* The last queue is not limited.
82	*/	82	*/
83	size_t sizes[ FREE_QUEUES_COUNT ];	83	size_t sizes[ FREE_QUEUES_COUNT ];
84	/** Total packets allocated.	84	/** Total packets allocated.
85	*/	85	*/
86	unsigned int count;	86	unsigned int count;
87	} ps_globals = {	87	} ps_globals = {
88	{ 1 },	88	{ 1 },
89	{ NULL, NULL, NULL, NULL, NULL, NULL, NULL },	89	{ NULL, NULL, NULL, NULL, NULL, NULL, NULL },
90	{ PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64 },	90	{ PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64 },
91	0	91	0
92	};	92	};
93		93
94	/** Returns the packet of dimensions at least as given.	94	/** Returns the packet of dimensions at least as given.
95	* Tries to reuse free packets first.	95	* Tries to reuse free packets first.
96	* Creates a new packet aligned to the memory page size if none available.	96	* Creates a new packet aligned to the memory page size if none available.
97	* Locks the global data during its processing.	97	* Locks the global data during its processing.
98	* @param addr_len The source and destination addresses maximal length in bytes. Input parameter.	98	* @param addr_len The source and destination addresses maximal length in bytes. Input parameter.
99	* @param max_prefix The maximal prefix length in bytes. Input parameter.	99	* @param max_prefix The maximal prefix length in bytes. Input parameter.
100	* @param max_content The maximal content length in bytes. Input parameter.	100	* @param max_content The maximal content length in bytes. Input parameter.
101	* @param max_suffix The maximal suffix length in bytes. Input parameter.	101	* @param max_suffix The maximal suffix length in bytes. Input parameter.
102	* @returns The packet of dimensions at least as given.	102	* @returns The packet of dimensions at least as given.
103	* @returns NULL if there is not enough memory left.	103	* @returns NULL if there is not enough memory left.
104	*/	104	*/
105	packet_t packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );	105	packet_t packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
106		106
107	/** Releases the packet queue.	107	/** Releases the packet queue.
108	* @param packet_id The first packet identifier. Input parameter.	108	* @param packet_id The first packet identifier. Input parameter.
109	* @returns EOK on success.	109	* @returns EOK on success.
110	* @returns ENOENT if there is no such packet.	110	* @returns ENOENT if there is no such packet.
111	*/	111	*/
112	int packet_release_wrapper( packet_id_t packet_id );	112	int packet_release_wrapper( packet_id_t packet_id );
113		113
114	/** Releases the packet and returns it to the appropriate free packet queue.	114	/** Releases the packet and returns it to the appropriate free packet queue.
115	* Should be used only when the global data are locked.	115	* Should be used only when the global data are locked.
116	* @param packet The packet to be released. Input parameter.	116	* @param packet The packet to be released. Input parameter.
117	*/	117	*/
118	void packet_release( packet_t packet );	118	void packet_release( packet_t packet );
119		119
120	/** Creates a new packet of dimensions at least as given.	120	/** Creates a new packet of dimensions at least as given.
121	* Should be used only when the global data are locked.	121	* Should be used only when the global data are locked.
122	* @param length The total length of the packet, including the header, the addresses and the data of the packet. Input parameter.	122	* @param length The total length of the packet, including the header, the addresses and the data of the packet. Input parameter.
123	* @param addr_len The source and destination addresses maximal length in bytes. Input parameter.	123	* @param addr_len The source and destination addresses maximal length in bytes. Input parameter.
124	* @param max_prefix The maximal prefix length in bytes. Input parameter.	124	* @param max_prefix The maximal prefix length in bytes. Input parameter.
125	* @param max_content The maximal content length in bytes. Input parameter.	125	* @param max_content The maximal content length in bytes. Input parameter.
126	* @param max_suffix The maximal suffix length in bytes. Input parameter.	126	* @param max_suffix The maximal suffix length in bytes. Input parameter.
127	* @returns The packet of dimensions at least as given.	127	* @returns The packet of dimensions at least as given.
128	* @returns NULL if there is not enough memory left.	128	* @returns NULL if there is not enough memory left.
129	*/	129	*/
130	packet_t packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );	130	packet_t packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
131		131
132	/** Clears and initializes the packet according to the given dimensions.	132	/** Clears and initializes the packet according to the given dimensions.
133	* @param packet The packet to be initialized. Input parameter.	133	* @param packet The packet to be initialized. Input parameter.
134	* @param addr_len The source and destination addresses maximal length in bytes. Input parameter.	134	* @param addr_len The source and destination addresses maximal length in bytes. Input parameter.
135	* @param max_prefix The maximal prefix length in bytes. Input parameter.	135	* @param max_prefix The maximal prefix length in bytes. Input parameter.
136	* @param max_content The maximal content length in bytes. Input parameter.	136	* @param max_content The maximal content length in bytes. Input parameter.
137	* @param max_suffix The maximal suffix length in bytes. Input parameter.	137	* @param max_suffix The maximal suffix length in bytes. Input parameter.
138	*/	138	*/
139	void packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );	139	void packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix );
140		140
141	/** Shares the packet memory block.	141	/** Shares the packet memory block.
142	* @param packet The packet to be shared.	142	* @param packet The packet to be shared.
143	* @returns EOK on success.	143	* @returns EOK on success.
144	* @returns EINVAL if the packet is not valid.	144	* @returns EINVAL if the packet is not valid.
145	* @returns EINVAL if the calling module does not accept the memory.	145	* @returns EINVAL if the calling module does not accept the memory.
146	* @returns ENOMEM if the desired and actual sizes differ.	146	* @returns ENOMEM if the desired and actual sizes differ.
147	* @returns Other error codes as defined for the ipc_share_in_finalize() function.	147	* @returns Other error codes as defined for the ipc_share_in_finalize() function.
148	*/	148	*/
149	int packet_reply( const packet_t packet );	149	int packet_reply( const packet_t packet );
150		150
151	int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){	151	int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){
152	if( ! packet ) return EINVAL;	152	if( ! packet ) return EINVAL;
153	* packet = pm_find( packet_id );	153	* packet = pm_find( packet_id );
154	return ( * packet ) ? EOK : ENOENT;	154	return ( * packet ) ? EOK : ENOENT;
155	}	155	}
156		156
157	packet_t packet_get_4( int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix ){	157	packet_t packet_get_4( int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix ){
158	return packet_get( addr_len, max_prefix, max_content, max_suffix );	158	return packet_get( addr_len, max_prefix, max_content, max_suffix );
159	}	159	}
160		160
161	packet_t packet_get_1( int phone, size_t content ){	161	packet_t packet_get_1( int phone, size_t content ){
162	return packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX );	162	return packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX );
163	}	163	}
164		164
165	void pq_release( int phone, packet_id_t packet_id ){	165	void pq_release( int phone, packet_id_t packet_id ){
166	( void ) packet_release_wrapper( packet_id );	166	( void ) packet_release_wrapper( packet_id );
167	}	167	}
168		168
169	int packet_server_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	169	int packet_server_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
170	packet_t packet;	170	packet_t packet;
171		171
172	* answer_count = 0;	172	* answer_count = 0;
173	switch( IPC_GET_METHOD( * call )){	173	switch( IPC_GET_METHOD( * call )){
174	case IPC_M_PHONE_HUNGUP:	174	case IPC_M_PHONE_HUNGUP:
175	return EOK;	175	return EOK;
176	case NET_PACKET_CREATE_1:	176	case NET_PACKET_CREATE_1:
177	packet = packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT( call ), DEFAULT_SUFFIX );	177	packet = packet_get( DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT( call ), DEFAULT_SUFFIX );
178	if( ! packet ) return ENOMEM;	178	if( ! packet ) return ENOMEM;
179	* answer_count = 2;	179	* answer_count = 2;
180	IPC_SET_ARG1( * answer, packet->packet_id );	180	IPC_SET_ARG1( * answer, packet->packet_id );
181	IPC_SET_ARG2( * answer, packet->length );	181	IPC_SET_ARG2( * answer, packet->length );
182	return EOK;	182	return EOK;
183	case NET_PACKET_CREATE_4:	183	case NET_PACKET_CREATE_4:
184	packet = packet_get( IPC_GET_ADDR_LEN( call ), IPC_GET_PREFIX( call ), IPC_GET_CONTENT( call ), IPC_GET_SUFFIX( call ));	184	packet = packet_get( IPC_GET_ADDR_LEN( call ), IPC_GET_PREFIX( call ), IPC_GET_CONTENT( call ), IPC_GET_SUFFIX( call ));
185	if( ! packet ) return ENOMEM;	185	if( ! packet ) return ENOMEM;
186	* answer_count = 2;	186	* answer_count = 2;
187	IPC_SET_ARG1( * answer, packet->packet_id );	187	IPC_SET_ARG1( * answer, packet->packet_id );
188	IPC_SET_ARG2( * answer, packet->length );	188	IPC_SET_ARG2( * answer, packet->length );
189	return EOK;	189	return EOK;
190	case NET_PACKET_GET:	190	case NET_PACKET_GET:
191	packet = pm_find( IPC_GET_ID( call ));	191	packet = pm_find( IPC_GET_ID( call ));
192	if( ! packet_is_valid( packet )) return ENOENT;	192	if( ! packet_is_valid( packet )) return ENOENT;
193	return packet_reply( packet );	193	return packet_reply( packet );
194	case NET_PACKET_GET_SIZE:	194	case NET_PACKET_GET_SIZE:
195	packet = pm_find( IPC_GET_ID( call ));	195	packet = pm_find( IPC_GET_ID( call ));
196	if( ! packet_is_valid( packet )) return ENOENT;	196	if( ! packet_is_valid( packet )) return ENOENT;
197	* answer_count = 1;	-
198	IPC_SET_ARG1( * answer, packet->length );	197	IPC_SET_ARG1( * answer, packet->length );
-		198	* answer_count = 1;
199	return EOK;	199	return EOK;
200	case NET_PACKET_RELEASE:	200	case NET_PACKET_RELEASE:
201	return packet_release_wrapper( IPC_GET_ID( call ));	201	return packet_release_wrapper( IPC_GET_ID( call ));
202	}	202	}
203	return ENOTSUP;	203	return ENOTSUP;
204	}	204	}
205		205
206	int packet_release_wrapper( packet_id_t packet_id ){	206	int packet_release_wrapper( packet_id_t packet_id ){
207	packet_t packet;	207	packet_t packet;
208		208
209	packet = pm_find( packet_id );	209	packet = pm_find( packet_id );
210	if( ! packet_is_valid( packet )) return ENOENT;	210	if( ! packet_is_valid( packet )) return ENOENT;
211	futex_down( & ps_globals.lock );	211	futex_down( & ps_globals.lock );
212	pq_destroy( packet, packet_release );	212	pq_destroy( packet, packet_release );
213	futex_up( & ps_globals.lock );	213	futex_up( & ps_globals.lock );
214	return EOK;	214	return EOK;
215	}	215	}
216		216
217	void packet_release( packet_t packet ){	217	void packet_release( packet_t packet ){
218	int index;	218	int index;
219		219
220	for( index = 0; ( index < FREE_QUEUES_COUNT - 1 ) && ( packet->length > ps_globals.sizes[ index ] ); ++ index );	220	for( index = 0; ( index < FREE_QUEUES_COUNT - 1 ) && ( packet->length > ps_globals.sizes[ index ] ); ++ index );
221	ps_globals.free[ index ] = pq_add( ps_globals.free[ index ], packet, packet->length, packet->length );	221	ps_globals.free[ index ] = pq_add( ps_globals.free[ index ], packet, packet->length, packet->length );
222	}	222	}
223		223
224	packet_t packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){	224	packet_t packet_get( size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
225	int index;	225	int index;
226	packet_t packet;	226	packet_t packet;
227	size_t length;	227	size_t length;
228		228
229	length = ALIGN_UP( sizeof( struct packet ) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE );	229	length = ALIGN_UP( sizeof( struct packet ) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE );
230	futex_down( & ps_globals.lock );	230	futex_down( & ps_globals.lock );
231	for( index = 0; index < FREE_QUEUES_COUNT - 1; ++ index ){	231	for( index = 0; index < FREE_QUEUES_COUNT - 1; ++ index ){
232	if( length <= ps_globals.sizes[ index ] ){	232	if( length <= ps_globals.sizes[ index ] ){
233	packet = ps_globals.free[ index ];	233	packet = ps_globals.free[ index ];
234	while( packet_is_valid( packet ) && ( packet->length < length )){	234	while( packet_is_valid( packet ) && ( packet->length < length )){
235	packet = pm_find( packet->next );	235	packet = pm_find( packet->next );
236	}	236	}
-		237	if( packet_is_valid( packet )){
-		238	if( packet == ps_globals.free[ index ] ){
-		239	ps_globals.free[ index ] = pq_detach( packet );
-		240	}else{
237	if( packet ){	241	pq_detach( packet );
-		242	}
238	packet_init( packet, addr_len, max_prefix, max_content, max_suffix );	243	packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
239	futex_up( & ps_globals.lock );	244	futex_up( & ps_globals.lock );
240	return packet;	245	return packet;
241	}	246	}
242	}	247	}
243	}	248	}
244	packet = packet_create( length, addr_len, max_prefix, max_content, max_suffix );	249	packet = packet_create( length, addr_len, max_prefix, max_content, max_suffix );
245	futex_up( & ps_globals.lock );	250	futex_up( & ps_globals.lock );
246	return packet;	251	return packet;
247	}	252	}
248		253
249	packet_t packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){	254	packet_t packet_create( size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
250	ERROR_DECLARE;	255	ERROR_DECLARE;
251		256
252	packet_t packet;	257	packet_t packet;
253		258
254	// already locked	259	// already locked
255	packet = ( packet_t ) mmap( NULL, length, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0 );	260	packet = ( packet_t ) mmap( NULL, length, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0 );
256	if( packet == MAP_FAILED ) return NULL;	261	if( packet == MAP_FAILED ) return NULL;
257	++ ps_globals.count;	262	++ ps_globals.count;
258	packet->packet_id = ps_globals.count;	263	packet->packet_id = ps_globals.count;
259	packet->length = length;	264	packet->length = length;
260	packet_init( packet, addr_len, max_prefix, max_content, max_suffix );	265	packet_init( packet, addr_len, max_prefix, max_content, max_suffix );
-		266	packet->magic_value = PACKET_MAGIC_VALUE;
261	if( ERROR_OCCURRED( pm_add( packet ))){	267	if( ERROR_OCCURRED( pm_add( packet ))){
262	munmap( packet, packet->length );	268	munmap( packet, packet->length );
263	return NULL;	269	return NULL;
264	}	270	}
265	packet_release( packet );	-
266	return packet;	271	return packet;
267	}	272	}
268		273
269	void packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){	274	void packet_init( packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix ){
270	int length;	-
271		-
272	// clear whole packet	275	// clear the packet content
273	length = packet->length;	-
274	bzero( packet, packet->length );	276	bzero((( void * ) packet ) + sizeof( struct packet ), packet->length - sizeof( struct packet ));
275	packet->length = length;	-
276	packet->magic_value = PACKET_MAGIC_VALUE;	-
277	/* // clear the packet header	277	// clear the packet header
278	packet->order = 0;	278	packet->order = 0;
279	packet->metric = 0;	279	packet->metric = 0;
280	packet->previous = 0;	280	packet->previous = 0;
281	packet->next = 0;	281	packet->next = 0;
282	packet->addr_len = 0;	282	packet->addr_len = 0;
283	*/ packet->src_addr = sizeof( struct packet );	283	packet->src_addr = sizeof( struct packet );
284	packet->dest_addr = packet->src_addr + addr_len;	284	packet->dest_addr = packet->src_addr + addr_len;
285	packet->max_prefix = max_prefix;	285	packet->max_prefix = max_prefix;
286	packet->max_content = max_content;	286	packet->max_content = max_content;
287	packet->data_start = packet->dest_addr + addr_len + packet->max_prefix;	287	packet->data_start = packet->dest_addr + addr_len + packet->max_prefix;
288	packet->data_end = packet->data_start;	288	packet->data_end = packet->data_start;
289	}	289	}
290		290
291	int packet_reply( const packet_t packet ){	291	int packet_reply( const packet_t packet ){
292	ipc_callid_t callid;	292	ipc_callid_t callid;
293	size_t size;	293	size_t size;
294		294
295	if( ! packet_is_valid( packet )) return EINVAL;	295	if( ! packet_is_valid( packet )) return EINVAL;
296	if( ipc_share_in_receive( & callid, & size ) <= 0 ) return EINVAL;	296	if( ipc_share_in_receive( & callid, & size ) <= 0 ) return EINVAL;
297	if( size != packet->length ) return ENOMEM;	297	if( size != packet->length ) return ENOMEM;
298	return ipc_share_in_finalize( callid, packet, PROTO_READ \| PROTO_WRITE );	298	return ipc_share_in_finalize( callid, packet, PROTO_READ \| PROTO_WRITE );
299	}	299	}
300		300
301	/** @}	301	/** @}
302	*/	302	*/
303		303

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/structures/packet/packet_server.c – Rev 4395 → 4505