1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/*
* Instantiate a private user environment for the calling thread.
*
* Submitted by: fernando.ruiz@ctv.es (correo@fernando-ruiz.com)
*
* COPYRIGHT (c) 1989-2010.
* On-Line Applications Research Corporation (OAR).
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.com/license/LICENSE.
*
* $Id$
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h> /* free */
#include <rtems.h>
#include <rtems/chain.h>
#include <rtems/libio.h>
#include <rtems/libio_.h>
#if defined(RTEMS_DEBUG)
#define CHECK_STATUS(_x) assert((_x) == )
#include <assert.h>
#else
#define CHECK_STATUS(_x) _x
#endif
/* cleanup a user environment
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc;
rtems_id task_id;
rtems_filesystem_location_info_t loc;
task_id = rtems_task_self();
/*
* Malloc is necessary whenever the current task does not
* have its own environment in place. This could be:
* a) it never had one
* OR
* b) it shared another task's environment
*/
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (rtems_current_user_env==&rtems_global_user_env ||
rtems_current_user_env->task_id != task_id ) {
rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t));
if (!tmp)
return RTEMS_NO_MEMORY;
#ifdef HAVE_USERENV_REFCNT
tmp->refcnt = 1;
#endif
sc = rtems_task_variable_add(
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
/* don't use free_user_env because the pathlocs are
* not initialized yet
*/
free(tmp);
return sc;
}
rtems_current_user_env = tmp;
}
*rtems_current_user_env = rtems_global_user_env; /* get the global values*/
rtems_current_user_env->task_id=task_id; /* mark the local values*/
/* Clone the pathlocs. In contrast to most other code we must _not_
* free the original locs because what we are trying to do here is forking
* off clones. The reason is a pathloc can be allocated by the file system
* and needs to be freed when deleting the environment.
*
* NOTE: Evaluation should always work so only check status when debug
* is enabled.
*/
CHECK_STATUS( rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0) );
rtems_filesystem_root = loc;
CHECK_STATUS( rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0) );
rtems_filesystem_current = loc;
return RTEMS_SUCCESSFUL;
}
/*
* Share the same private environment between two tasks:
* Task_id (remote) and RTEMS_SELF(current).
*/
/* NOTE:
*
* THIS CODE HAS NO PROTECTION IMPLEMENTED
*
* Tasks who wish to share their environments must
*
* a) assert that no participants are concurrently
* executing
* libio_share_private_env() and/or libio_set_private_env()
*
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
rtems_status_code sc;
rtems_user_env_t * shared_user_env;
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
task_id,
(void*)&rtems_current_user_env,
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
return sc;
/*
* If we are here, we have the required environment to be
* shared with the current task
*/
/*
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
/* increase the reference count */
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
|
