← Back to branch summary

~martin-decky/helenos/rcu

« back to all changes in this revision

Viewing changes to uspace/lib/net/generic/packet_remote.c

  • Committer: Martin Sucha
  • Date: 2011-07-08 17:01:01 UTC
  • mfrom: (1095 main-clone)
  • mto: This revision was merged to the branch mainline in revision 1123.
  • Revision ID: sucha14@st.fmph.uniba.sk-20110708170101-eosjw1koauuvmzkz
Merge mainline changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/lib/net/generic/packet_remote.c
50
50
 *
51
51
 * Create the local packet mapping as well.
52
52
 *
53
 
 * @param[in]  phone     The packet server module phone.
54
 
 * @param[out] packet    The packet reference pointer to store the received
 
53
 * @param[in]  sess      Packet server module session.
 
54
 * @param[out] packet    Packet reference pointer to store the received
55
55
 *                       packet reference.
56
 
 * @param[in]  packet_id The packet identifier.
57
 
 * @param[in]  size      The packet total size in bytes.
 
56
 * @param[in]  packet_id Packet identifier.
 
57
 * @param[in]  size      Packet total size in bytes.
58
58
 *
59
59
 * @return EOK on success.
60
60
 * @return Other error codes as defined for the pm_add() function.
61
 
 * @return Other error codes as defined for the async_share_in_start() function.
 
61
 * @return Other error codes as defined for the async_share_in_start()
 
62
 *         function.
62
63
 *
63
64
 */
64
 
static int
65
 
packet_return(int phone, packet_t **packet, packet_id_t packet_id, size_t size)
 
65
static int packet_return(async_sess_t *sess, packet_t **packet,
 
66
    packet_id_t packet_id, size_t size)
66
67
{
 
68
        *packet = (packet_t *) as_get_mappable_page(size);
 
69
        
 
70
        async_exch_t *exch = async_exchange_begin(sess);
67
71
        ipc_call_t answer;
68
 
        aid_t message;
69
 
        int rc;
70
 
        
71
 
        message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
72
 
 
73
 
        *packet = (packet_t *) as_get_mappable_page(size);
74
 
        rc = async_share_in_start_0_0(phone, *packet, size);
75
 
        if (rc != EOK) {
76
 
                munmap(*packet, size);
77
 
                async_wait_for(message, NULL);
78
 
                return rc;
79
 
        }
80
 
        rc = pm_add(*packet);
81
 
        if (rc != EOK) {
82
 
                munmap(*packet, size);
83
 
                async_wait_for(message, NULL);
84
 
                return rc;
85
 
        }
 
72
        aid_t message = async_send_1(exch, NET_PACKET_GET, packet_id, &answer);
 
73
        int rc = async_share_in_start_0_0(exch, *packet, size);
 
74
        async_exchange_end(exch);
86
75
        
87
76
        sysarg_t result;
88
77
        async_wait_for(message, &result);
89
78
        
 
79
        if (rc != EOK) {
 
80
                munmap(*packet, size);
 
81
                return rc;
 
82
        }
 
83
        
 
84
        rc = pm_add(*packet);
 
85
        if (rc != EOK) {
 
86
                munmap(*packet, size);
 
87
                return rc;
 
88
        }
 
89
        
90
90
        return result;
91
91
}
92
92
 
93
 
/** Translates the packet identifier to the packet reference.
94
 
 *
95
 
 * Tries to find mapping first.
96
 
 * Contacts the packet server to share the packet if the mapping is not present.
97
 
 *
98
 
 * @param[in] phone     The packet server module phone.
99
 
 * @param[out] packet   The packet reference.
100
 
 * @param[in] packet_id The packet identifier.
101
 
 * @return              EOK on success.
102
 
 * @return              EINVAL if the packet parameter is NULL.
103
 
 * @return              Other error codes as defined for the NET_PACKET_GET_SIZE
104
 
 *                      message.
105
 
 * @return              Other error codes as defined for the packet_return()
106
 
 *                      function.
 
93
/** Translate the packet identifier to the packet reference.
 
94
 *
 
95
 * Try to find mapping first. The packet server is asked to share
 
96
 * the packet if the mapping is not present.
 
97
 *
 
98
 * @param[in]  sess      Packet server module session.
 
99
 * @param[out] packet    Packet reference.
 
100
 * @param[in]  packet_id Packet identifier.
 
101
 *
 
102
 * @return EOK on success.
 
103
 * @return EINVAL if the packet parameter is NULL.
 
104
 * @return Other error codes as defined for the NET_PACKET_GET_SIZE
 
105
 *         message.
 
106
 * @return Other error codes as defined for the packet_return()
 
107
 *         function.
 
108
 *
107
109
 */
108
 
int packet_translate_remote(int phone, packet_t **packet, packet_id_t packet_id)
 
110
int packet_translate_remote(async_sess_t *sess, packet_t **packet,
 
111
    packet_id_t packet_id)
109
112
{
110
 
        int rc;
111
 
        
112
113
        if (!packet)
113
114
                return EINVAL;
114
115
        
115
116
        *packet = pm_find(packet_id);
116
117
        if (!*packet) {
 
118
                async_exch_t *exch = async_exchange_begin(sess);
117
119
                sysarg_t size;
118
 
                
119
 
                rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
 
120
                int rc = async_req_1_1(exch, NET_PACKET_GET_SIZE, packet_id,
120
121
                    &size);
 
122
                async_exchange_end(exch);
 
123
                
121
124
                if (rc != EOK)
122
125
                        return rc;
123
 
                rc = packet_return(phone, packet, packet_id, size);
 
126
                
 
127
                rc = packet_return(sess, packet, packet_id, size);
124
128
                if (rc != EOK)
125
129
                        return rc;
126
130
        }
 
131
        
127
132
        if ((*packet)->next) {
128
133
                packet_t *next;
129
 
                
130
 
                return packet_translate_remote(phone, &next, (*packet)->next);
 
134
                return packet_translate_remote(sess, &next, (*packet)->next);
131
135
        }
132
136
        
133
137
        return EOK;
134
138
}
135
139
 
136
 
/** Obtains the packet of the given dimensions.
137
 
 *
138
 
 * Contacts the packet server to return the appropriate packet.
139
 
 *
140
 
 * @param[in] phone     The packet server module phone.
141
 
 * @param[in] addr_len  The source and destination addresses maximal length in
142
 
 *                      bytes.
143
 
 * @param[in] max_prefix The maximal prefix length in bytes.
144
 
 * @param[in] max_content The maximal content length in bytes.
145
 
 * @param[in] max_suffix The maximal suffix length in bytes.
146
 
 * @return              The packet reference.
147
 
 * @return              NULL on error.
 
140
/** Obtain the packet of given dimensions.
 
141
 *
 
142
 * Contact the packet server to return the appropriate packet.
 
143
 *
 
144
 * @param[in] sess        Packet server module session.
 
145
 * @param[in] addr_len    Source and destination addresses maximal length
 
146
 *                        in bytes.
 
147
 * @param[in] max_prefix  Maximal prefix length in bytes.
 
148
 * @param[in] max_content Maximal content length in bytes.
 
149
 * @param[in] max_suffix  Maximal suffix length in bytes.
 
150
 *
 
151
 * @return The packet reference.
 
152
 * @return NULL on error.
 
153
 *
148
154
 */
149
 
packet_t *packet_get_4_remote(int phone, size_t max_content, size_t addr_len,
150
 
    size_t max_prefix, size_t max_suffix)
 
155
packet_t *packet_get_4_remote(async_sess_t *sess, size_t max_content,
 
156
    size_t addr_len, size_t max_prefix, size_t max_suffix)
151
157
{
 
158
        async_exch_t *exch = async_exchange_begin(sess);
152
159
        sysarg_t packet_id;
153
160
        sysarg_t size;
154
 
        int rc;
155
 
        
156
 
        rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
 
161
        int rc = async_req_4_2(exch, NET_PACKET_CREATE_4, max_content, addr_len,
157
162
            max_prefix, max_suffix, &packet_id, &size);
 
163
        async_exchange_end(exch);
 
164
        
158
165
        if (rc != EOK)
159
166
                return NULL;
160
167
        
161
 
        
162
168
        packet_t *packet = pm_find(packet_id);
163
169
        if (!packet) {
164
 
                rc = packet_return(phone, &packet, packet_id, size);
 
170
                rc = packet_return(sess, &packet, packet_id, size);
165
171
                if (rc != EOK)
166
172
                        return NULL;
167
173
        }
169
175
        return packet;
170
176
}
171
177
 
172
 
/** Obtains the packet of the given content size.
173
 
 *
174
 
 * Contacts the packet server to return the appropriate packet.
175
 
 *
176
 
 * @param[in] phone     The packet server module phone.
177
 
 * @param[in] content   The maximal content length in bytes.
178
 
 * @return              The packet reference.
179
 
 * @return              NULL on error.
 
178
/** Obtain the packet of given content size.
 
179
 *
 
180
 * Contact the packet server to return the appropriate packet.
 
181
 *
 
182
 * @param[in] sess    Packet server module session.
 
183
 * @param[in] content Maximal content length in bytes.
 
184
 *
 
185
 * @return The packet reference.
 
186
 * @return NULL on error.
 
187
 *
180
188
 */
181
 
packet_t *packet_get_1_remote(int phone, size_t content)
 
189
packet_t *packet_get_1_remote(async_sess_t *sess, size_t content)
182
190
{
 
191
        async_exch_t *exch = async_exchange_begin(sess);
183
192
        sysarg_t packet_id;
184
193
        sysarg_t size;
185
 
        int rc;
186
 
        
187
 
        rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
 
194
        int rc = async_req_1_2(exch, NET_PACKET_CREATE_1, content, &packet_id,
188
195
            &size);
 
196
        async_exchange_end(exch);
 
197
        
189
198
        if (rc != EOK)
190
199
                return NULL;
191
200
        
192
201
        packet_t *packet = pm_find(packet_id);
193
202
        if (!packet) {
194
 
                rc = packet_return(phone, &packet, packet_id, size);
 
203
                rc = packet_return(sess, &packet, packet_id, size);
195
204
                if (rc != EOK)
196
205
                        return NULL;
197
206
        }
199
208
        return packet;
200
209
}
201
210
 
202
 
/** Releases the packet queue.
 
211
/** Release the packet queue.
203
212
 *
204
213
 * All packets in the queue are marked as free for use.
205
214
 * The packet queue may be one packet only.
206
215
 * The module should not use the packets after this point until they are
207
216
 * received or obtained again.
208
217
 *
209
 
 * @param[in] phone     The packet server module phone.
210
 
 * @param[in] packet_id The packet identifier.
 
218
 * @param[in] sess      Packet server module session.
 
219
 * @param[in] packet_id Packet identifier.
 
220
 *
211
221
 */
212
 
void pq_release_remote(int phone, packet_id_t packet_id)
 
222
void pq_release_remote(async_sess_t *sess, packet_id_t packet_id)
213
223
{
214
 
        async_msg_1(phone, NET_PACKET_RELEASE, packet_id);
 
224
        async_exch_t *exch = async_exchange_begin(sess);
 
225
        async_msg_1(exch, NET_PACKET_RELEASE, packet_id);
 
226
        async_exchange_end(exch);
215
227
}
216
228
 
217
229
/** @}