Subversion Repositories HelenOS

Rev

Rev 2852 | Rev 2863 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2852 Rev 2857
1
/*
1
/*
2
 * Copyright (c) 2008 Jakub Jermar
2
 * Copyright (c) 2008 Jakub Jermar
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 libfs
29
/** @addtogroup libfs
30
 * @{
30
 * @{
31
 */
31
 */
32
/**
32
/**
33
 * @file
33
 * @file
34
 * Glue code which is commonod to all FS implementations.
34
 * Glue code which is commonod to all FS implementations.
35
 */
35
 */
36
 
36
 
37
#include "libfs.h" 
37
#include "libfs.h" 
38
#include "../../srv/vfs/vfs.h"
38
#include "../../srv/vfs/vfs.h"
39
#include <errno.h>
39
#include <errno.h>
40
#include <async.h>
40
#include <async.h>
41
#include <ipc/ipc.h>
41
#include <ipc/ipc.h>
42
#include <as.h>
42
#include <as.h>
43
#include <assert.h>
43
#include <assert.h>
44
#include <dirent.h>
44
#include <dirent.h>
45
 
45
 
46
/** Register file system server.
46
/** Register file system server.
47
 *
47
 *
48
 * This function abstracts away the tedious registration protocol from
48
 * This function abstracts away the tedious registration protocol from
49
 * file system implementations and lets them to reuse this registration glue
49
 * file system implementations and lets them to reuse this registration glue
50
 * code.
50
 * code.
51
 *
51
 *
52
 * @param vfs_phone Open phone for communication with VFS.
52
 * @param vfs_phone Open phone for communication with VFS.
53
 * @param reg       File system registration structure. It will be
53
 * @param reg       File system registration structure. It will be
54
 *          initialized by this function.
54
 *          initialized by this function.
55
 * @param info      VFS info structure supplied by the file system
55
 * @param info      VFS info structure supplied by the file system
56
 *          implementation.
56
 *          implementation.
57
 * @param conn      Connection fibril for handling all calls originating in
57
 * @param conn      Connection fibril for handling all calls originating in
58
 *          VFS.
58
 *          VFS.
59
 *
59
 *
60
 * @return      EOK on success or a non-zero error code on errror.
60
 * @return      EOK on success or a non-zero error code on errror.
61
 */
61
 */
62
int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info,
62
int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info,
63
    async_client_conn_t conn)
63
    async_client_conn_t conn)
64
{
64
{
65
    /*
65
    /*
66
     * Tell VFS that we are here and want to get registered.
66
     * Tell VFS that we are here and want to get registered.
67
     * We use the async framework because VFS will answer the request
67
     * We use the async framework because VFS will answer the request
68
     * out-of-order, when it knows that the operation succeeded or failed.
68
     * out-of-order, when it knows that the operation succeeded or failed.
69
     */
69
     */
70
    ipc_call_t answer;
70
    ipc_call_t answer;
71
    aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer);
71
    aid_t req = async_send_0(vfs_phone, VFS_REGISTER, &answer);
72
 
72
 
73
    /*
73
    /*
74
     * Send our VFS info structure to VFS.
74
     * Send our VFS info structure to VFS.
75
     */
75
     */
76
    int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
76
    int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
77
    if (rc != EOK) {
77
    if (rc != EOK) {
78
        async_wait_for(req, NULL);
78
        async_wait_for(req, NULL);
79
        return rc;
79
        return rc;
80
    }
80
    }
81
 
81
 
82
    /*
82
    /*
83
     * Ask VFS for callback connection.
83
     * Ask VFS for callback connection.
84
     */
84
     */
85
    ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
85
    ipc_connect_to_me(vfs_phone, 0, 0, 0, &reg->vfs_phonehash);
86
 
86
 
87
    /*
87
    /*
88
     * Allocate piece of address space for PLB.
88
     * Allocate piece of address space for PLB.
89
     */
89
     */
90
    reg->plb_ro = as_get_mappable_page(PLB_SIZE);
90
    reg->plb_ro = as_get_mappable_page(PLB_SIZE);
91
    if (!reg->plb_ro) {
91
    if (!reg->plb_ro) {
92
        async_wait_for(req, NULL);
92
        async_wait_for(req, NULL);
93
        return ENOMEM;
93
        return ENOMEM;
94
    }
94
    }
95
 
95
 
96
    /*
96
    /*
97
     * Request sharing the Path Lookup Buffer with VFS.
97
     * Request sharing the Path Lookup Buffer with VFS.
98
     */
98
     */
99
    rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
99
    rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
100
    if (rc) {
100
    if (rc) {
101
        async_wait_for(req, NULL);
101
        async_wait_for(req, NULL);
102
        return rc;
102
        return rc;
103
    }
103
    }
104
     
104
     
105
    /*
105
    /*
106
     * Pick up the answer for the request to the VFS_REQUEST call.
106
     * Pick up the answer for the request to the VFS_REQUEST call.
107
     */
107
     */
108
    async_wait_for(req, NULL);
108
    async_wait_for(req, NULL);
109
    reg->fs_handle = (int) IPC_GET_ARG1(answer);
109
    reg->fs_handle = (int) IPC_GET_ARG1(answer);
110
   
110
   
111
    /*
111
    /*
112
     * Create a connection fibril to handle the callback connection.
112
     * Create a connection fibril to handle the callback connection.
113
     */
113
     */
114
    async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
114
    async_new_connection(reg->vfs_phonehash, 0, NULL, conn);
115
   
115
   
116
    /*
116
    /*
117
     * Tell the async framework that other connections are to be handled by
117
     * Tell the async framework that other connections are to be handled by
118
     * the same connection fibril as well.
118
     * the same connection fibril as well.
119
     */
119
     */
120
    async_set_client_connection(conn);
120
    async_set_client_connection(conn);
121
 
121
 
122
    return IPC_GET_RETVAL(answer);
122
    return IPC_GET_RETVAL(answer);
123
}
123
}
124
 
124
 
125
/** Lookup VFS triplet by name in the file system name space.
125
/** Lookup VFS triplet by name in the file system name space.
126
 *
126
 *
127
 * The path passed in the PLB must be in the canonical file system path format
127
 * The path passed in the PLB must be in the canonical file system path format
128
 * as returned by the canonify() function.
128
 * as returned by the canonify() function.
129
 *
129
 *
130
 * @param ops       libfs operations structure with function pointers to
130
 * @param ops       libfs operations structure with function pointers to
131
 *          file system implementation
131
 *          file system implementation
132
 * @param fs_handle File system handle of the file system where to perform
132
 * @param fs_handle File system handle of the file system where to perform
133
 *          the lookup.
133
 *          the lookup.
134
 * @param rid       Request ID of the VFS_LOOKUP request.
134
 * @param rid       Request ID of the VFS_LOOKUP request.
135
 * @param request   VFS_LOOKUP request data itself.
135
 * @param request   VFS_LOOKUP request data itself.
136
 */
136
 */
137
void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
137
void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
138
    ipc_call_t *request)
138
    ipc_call_t *request)
139
{
139
{
140
    unsigned next = IPC_GET_ARG1(*request);
140
    unsigned next = IPC_GET_ARG1(*request);
141
    unsigned last = IPC_GET_ARG2(*request);
141
    unsigned last = IPC_GET_ARG2(*request);
142
    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
142
    dev_handle_t dev_handle = IPC_GET_ARG3(*request);
143
    int lflag = IPC_GET_ARG4(*request);
143
    int lflag = IPC_GET_ARG4(*request);
144
    fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
144
    fs_index_t index = IPC_GET_ARG5(*request); /* when L_LINK specified */
145
    char component[NAME_MAX + 1];
145
    char component[NAME_MAX + 1];
146
    int len;
146
    int len;
147
 
147
 
148
    if (last < next)
148
    if (last < next)
149
        last += PLB_SIZE;
149
        last += PLB_SIZE;
150
 
150
 
151
    void *par = NULL;
151
    void *par = NULL;
152
    void *cur = ops->root_get(dev_handle);
152
    void *cur = ops->root_get(dev_handle);
153
    void *tmp = NULL;
153
    void *tmp = NULL;
154
 
154
 
155
    if (ops->plb_get_char(next) == '/')
155
    if (ops->plb_get_char(next) == '/')
156
        next++;     /* eat slash */
156
        next++;     /* eat slash */
157
   
157
   
158
    while (ops->has_children(cur) && next <= last) {
158
    while (ops->has_children(cur) && next <= last) {
159
        /* collect the component */
159
        /* collect the component */
160
        len = 0;
160
        len = 0;
161
        while ((ops->plb_get_char(next) != '/') && (next <= last)) {
161
        while ((ops->plb_get_char(next) != '/') && (next <= last)) {
162
            if (len + 1 == NAME_MAX) {
162
            if (len + 1 == NAME_MAX) {
163
                /* comopnent length overflow */
163
                /* comopnent length overflow */
164
                ipc_answer_0(rid, ENAMETOOLONG);
164
                ipc_answer_0(rid, ENAMETOOLONG);
165
                goto out;
165
                goto out;
166
            }
166
            }
167
            component[len++] = ops->plb_get_char(next);
167
            component[len++] = ops->plb_get_char(next);
168
            next++; /* process next character */
168
            next++; /* process next character */
169
        }
169
        }
170
 
170
 
171
        assert(len);
171
        assert(len);
172
        component[len] = '\0';
172
        component[len] = '\0';
173
        next++;     /* eat slash */
173
        next++;     /* eat slash */
174
 
174
 
175
        /* match the component */
175
        /* match the component */
176
        tmp = ops->match(cur, component);
176
        tmp = ops->match(cur, component);
177
 
177
 
178
        /* handle miss: match amongst siblings */
178
        /* handle miss: match amongst siblings */
179
        if (!tmp) {
179
        if (!tmp) {
180
            if (next <= last) {
180
            if (next <= last) {
181
                /* there are unprocessed components */
181
                /* there are unprocessed components */
182
                ipc_answer_0(rid, ENOENT);
182
                ipc_answer_0(rid, ENOENT);
183
                goto out;
183
                goto out;
184
            }
184
            }
185
            /* miss in the last component */
185
            /* miss in the last component */
186
            if (lflag & (L_CREATE | L_LINK)) {
186
            if (lflag & (L_CREATE | L_LINK)) {
187
                /* request to create a new link */
187
                /* request to create a new link */
188
                if (!ops->is_directory(cur)) {
188
                if (!ops->is_directory(cur)) {
189
                    ipc_answer_0(rid, ENOTDIR);
189
                    ipc_answer_0(rid, ENOTDIR);
190
                    goto out;
190
                    goto out;
191
                }
191
                }
192
                void *nodep;
192
                void *nodep;
193
                if (lflag & L_CREATE)
193
                if (lflag & L_CREATE)
194
                    nodep = ops->create(lflag);
194
                    nodep = ops->create(lflag);
195
                else
195
                else
196
                    nodep = ops->node_get(dev_handle,
196
                    nodep = ops->node_get(dev_handle,
197
                        index, ops->index_get(cur));
197
                        index, ops->index_get(cur));
198
                if (nodep) {
198
                if (nodep) {
199
                    if (!ops->link(cur, nodep, component)) {
199
                    if (!ops->link(cur, nodep, component)) {
200
                        if (lflag & L_CREATE)
200
                        if (lflag & L_CREATE)
201
                            ops->destroy(nodep);
201
                            (void)ops->destroy(nodep);
202
                        ipc_answer_0(rid, ENOSPC);
202
                        ipc_answer_0(rid, ENOSPC);
203
                    } else {
203
                    } else {
204
                        ipc_answer_5(rid, EOK,
204
                        ipc_answer_5(rid, EOK,
205
                            fs_handle, dev_handle,
205
                            fs_handle, dev_handle,
206
                            ops->index_get(nodep),
206
                            ops->index_get(nodep),
207
                            ops->size_get(nodep),
207
                            ops->size_get(nodep),
208
                            ops->lnkcnt_get(nodep));
208
                            ops->lnkcnt_get(nodep));
209
                        ops->node_put(nodep);
209
                        ops->node_put(nodep);
210
                    }
210
                    }
211
                } else {
211
                } else {
212
                    ipc_answer_0(rid, ENOSPC);
212
                    ipc_answer_0(rid, ENOSPC);
213
                }
213
                }
214
                goto out;
214
                goto out;
215
            } else if (lflag & L_PARENT) {
215
            } else if (lflag & L_PARENT) {
216
                /* return parent */
216
                /* return parent */
217
                ipc_answer_5(rid, EOK, fs_handle, dev_handle,
217
                ipc_answer_5(rid, EOK, fs_handle, dev_handle,
218
                    ops->index_get(cur), ops->size_get(cur),
218
                    ops->index_get(cur), ops->size_get(cur),
219
                    ops->lnkcnt_get(cur));
219
                    ops->lnkcnt_get(cur));
220
            }
220
            }
221
            ipc_answer_0(rid, ENOENT);
221
            ipc_answer_0(rid, ENOENT);
222
            goto out;
222
            goto out;
223
        }
223
        }
224
 
224
 
225
        if (par)
225
        if (par)
226
            ops->node_put(par);
226
            ops->node_put(par);
227
 
227
 
228
        /* descend one level */
228
        /* descend one level */
229
        par = cur;
229
        par = cur;
230
        cur = tmp;
230
        cur = tmp;
231
        tmp = NULL;
231
        tmp = NULL;
232
    }
232
    }
233
 
233
 
234
    /* handle miss: excessive components */
234
    /* handle miss: excessive components */
235
    if (!ops->has_children(cur) && next <= last) {
235
    if (!ops->has_children(cur) && next <= last) {
236
        if (lflag & (L_CREATE | L_LINK)) {
236
        if (lflag & (L_CREATE | L_LINK)) {
237
            if (!ops->is_directory(cur)) {
237
            if (!ops->is_directory(cur)) {
238
                ipc_answer_0(rid, ENOTDIR);
238
                ipc_answer_0(rid, ENOTDIR);
239
                goto out;
239
                goto out;
240
            }
240
            }
241
 
241
 
242
            /* collect next component */
242
            /* collect next component */
243
            len = 0;
243
            len = 0;
244
            while (next <= last) {
244
            while (next <= last) {
245
                if (ops->plb_get_char(next) == '/') {
245
                if (ops->plb_get_char(next) == '/') {
246
                    /* more than one component */
246
                    /* more than one component */
247
                    ipc_answer_0(rid, ENOENT);
247
                    ipc_answer_0(rid, ENOENT);
248
                    goto out;
248
                    goto out;
249
                }
249
                }
250
                if (len + 1 == NAME_MAX) {
250
                if (len + 1 == NAME_MAX) {
251
                    /* component length overflow */
251
                    /* component length overflow */
252
                    ipc_answer_0(rid, ENAMETOOLONG);
252
                    ipc_answer_0(rid, ENAMETOOLONG);
253
                    goto out;
253
                    goto out;
254
                }
254
                }
255
                component[len++] = ops->plb_get_char(next);
255
                component[len++] = ops->plb_get_char(next);
256
                next++; /* process next character */
256
                next++; /* process next character */
257
            }
257
            }
258
            assert(len);
258
            assert(len);
259
            component[len] = '\0';
259
            component[len] = '\0';
260
               
260
               
261
            void *nodep;
261
            void *nodep;
262
            if (lflag & L_CREATE)
262
            if (lflag & L_CREATE)
263
                nodep = ops->create(lflag);
263
                nodep = ops->create(lflag);
264
            else
264
            else
265
                nodep = ops->node_get(dev_handle, index,
265
                nodep = ops->node_get(dev_handle, index,
266
                    ops->index_get(cur));
266
                    ops->index_get(cur));
267
            if (nodep) {
267
            if (nodep) {
268
                if (!ops->link(cur, nodep, component)) {
268
                if (!ops->link(cur, nodep, component)) {
269
                    if (lflag & L_CREATE)
269
                    if (lflag & L_CREATE)
270
                        ops->destroy(nodep);
270
                        (void)ops->destroy(nodep);
271
                    ipc_answer_0(rid, ENOSPC);
271
                    ipc_answer_0(rid, ENOSPC);
272
                } else {
272
                } else {
273
                    ipc_answer_5(rid, EOK,
273
                    ipc_answer_5(rid, EOK,
274
                        fs_handle, dev_handle,
274
                        fs_handle, dev_handle,
275
                        ops->index_get(nodep),
275
                        ops->index_get(nodep),
276
                        ops->size_get(nodep),
276
                        ops->size_get(nodep),
277
                        ops->lnkcnt_get(nodep));
277
                        ops->lnkcnt_get(nodep));
278
                    ops->node_put(nodep);
278
                    ops->node_put(nodep);
279
                }
279
                }
280
            } else {
280
            } else {
281
                ipc_answer_0(rid, ENOSPC);
281
                ipc_answer_0(rid, ENOSPC);
282
            }
282
            }
283
            goto out;
283
            goto out;
284
        }
284
        }
285
        ipc_answer_0(rid, ENOENT);
285
        ipc_answer_0(rid, ENOENT);
286
        goto out;
286
        goto out;
287
    }
287
    }
288
 
288
 
289
    /* handle hit */
289
    /* handle hit */
290
    if (lflag & L_PARENT) {
290
    if (lflag & L_PARENT) {
291
        ops->node_put(cur);
291
        ops->node_put(cur);
292
        cur = par;
292
        cur = par;
293
        par = NULL;
293
        par = NULL;
294
        if (!cur) {
294
        if (!cur) {
295
            ipc_answer_0(rid, ENOENT);
295
            ipc_answer_0(rid, ENOENT);
296
            goto out;
296
            goto out;
297
        }
297
        }
298
    }
298
    }
299
    if (lflag & L_UNLINK) {
299
    if (lflag & L_UNLINK) {
300
        unsigned old_lnkcnt = ops->lnkcnt_get(cur);
300
        unsigned old_lnkcnt = ops->lnkcnt_get(cur);
301
        int res = ops->unlink(par, cur);
301
        int res = ops->unlink(par, cur);
302
        ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
302
        ipc_answer_5(rid, (ipcarg_t)res, fs_handle, dev_handle,
303
            ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
303
            ops->index_get(cur), ops->size_get(cur), old_lnkcnt);
304
        goto out;
304
        goto out;
305
    }
305
    }
306
    if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
306
    if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) ||
307
        (lflag & L_LINK)) {
307
        (lflag & L_LINK)) {
308
        ipc_answer_0(rid, EEXIST);
308
        ipc_answer_0(rid, EEXIST);
309
        goto out;
309
        goto out;
310
    }
310
    }
311
    if ((lflag & L_FILE) && (ops->is_directory(cur))) {
311
    if ((lflag & L_FILE) && (ops->is_directory(cur))) {
312
        ipc_answer_0(rid, EISDIR);
312
        ipc_answer_0(rid, EISDIR);
313
        goto out;
313
        goto out;
314
    }
314
    }
315
    if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
315
    if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) {
316
        ipc_answer_0(rid, ENOTDIR);
316
        ipc_answer_0(rid, ENOTDIR);
317
        goto out;
317
        goto out;
318
    }
318
    }
319
 
319
 
320
    ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
320
    ipc_answer_5(rid, EOK, fs_handle, dev_handle, ops->index_get(cur),
321
        ops->size_get(cur), ops->lnkcnt_get(cur));
321
        ops->size_get(cur), ops->lnkcnt_get(cur));
322
 
322
 
323
out:
323
out:
324
    if (par)
324
    if (par)
325
        ops->node_put(par);
325
        ops->node_put(par);
326
    if (cur)
326
    if (cur)
327
        ops->node_put(cur);
327
        ops->node_put(cur);
328
    if (tmp)
328
    if (tmp)
329
        ops->node_put(tmp);
329
        ops->node_put(tmp);
330
}
330
}
331
 
331
 
332
/** @}
332
/** @}
333
 */
333
 */
334
 
334