source: rtems/cpukit/libcsupport/include/rtems/libio_.h @ 66fac03

5
Last change on this file since 66fac03 was 66fac03, checked in by Sebastian Huber <sebastian.huber@…>, on 03/16/17 at 10:54:29

libio: Fix deadlock in location management

Perform a context-dependent deferred location release to avoid a
deadlock on the file system instance locks, for example during a
chdir().

Update #2936.

  • Property mode set to 100644
File size: 23.6 KB
Line 
1/**
2 * @file
3 *
4 * @brief LibIO Internal Interface
5 *
6 * This file is the libio internal interface.
7 */
8
9/*
10 *  COPYRIGHT (c) 1989-2011.
11 *  On-Line Applications Research Corporation (OAR).
12 *
13 *  Modifications to support reference counting in the file system are
14 *  Copyright (c) 2012 embedded brains GmbH.
15 *
16 *  The license and distribution terms for this file may be
17 *  found in the file LICENSE in this distribution or at
18 *  http://www.rtems.org/license/LICENSE.
19 */
20
21#ifndef _RTEMS_RTEMS_LIBIO__H
22#define _RTEMS_RTEMS_LIBIO__H
23
24#include <sys/uio.h>
25#include <errno.h>
26#include <limits.h>
27#include <pthread.h>
28
29#include <rtems.h>
30#include <rtems/libio.h>
31#include <rtems/seterr.h>
32
33#ifdef __cplusplus
34extern "C" {
35#endif
36
37/**
38 * @defgroup LibIOInternal IO Internal Library
39 *
40 * @brief Internal IO library API and implementation.
41 *
42 */
43/**@{**/
44
45#define RTEMS_FILESYSTEM_SYMLOOP_MAX 32
46
47/*
48 * Not defined in newlib so provide here. Users should use dup2 and
49 * not this non-portable fcntl command. Provided here to allow the
50 * RTEMS implementation to work.
51 */
52#define F_DUP2FD 20
53
54/*
55 *  Semaphore to protect the io table
56 */
57
58#define RTEMS_LIBIO_SEM         rtems_build_name('L', 'B', 'I', 'O')
59#define RTEMS_LIBIO_IOP_SEM(n)  rtems_build_name('L', 'B', 'I', n)
60
61extern rtems_id                          rtems_libio_semaphore;
62
63/*
64 *  File descriptor Table Information
65 */
66
67extern const uint32_t rtems_libio_number_iops;
68extern rtems_libio_t rtems_libio_iops[];
69extern rtems_libio_t *rtems_libio_iop_freelist;
70
71extern const rtems_filesystem_file_handlers_r rtems_filesystem_null_handlers;
72
73extern rtems_filesystem_mount_table_entry_t rtems_filesystem_null_mt_entry;
74
75/**
76 * @brief The global null location.
77 *
78 * Every operation and the open and fstat handlers of this location returns an
79 * error status.  The errno is not touched by these operations and handlers.
80 * The purpose of this location is to deliver the error return status for a
81 * previous error condition which must set the errno accordingly.
82 *
83 * The usage of this null location instead of the NULL pointer eliminates
84 * a lot of branches.
85 *
86 * The user environment root and current directory are statically initialized
87 * with the null location.  Due to that all file system services are in a
88 * defined state even if no root file system was mounted.
89 */
90extern rtems_filesystem_global_location_t rtems_filesystem_global_location_null;
91
92/*
93 *  rtems_libio_iop
94 *
95 *  Macro to return the file descriptor pointer.
96 */
97
98#define rtems_libio_iop(_fd) \
99  ((((uint32_t)(_fd)) < rtems_libio_number_iops) ? \
100         &rtems_libio_iops[_fd] : 0)
101
102/*
103 *  rtems_libio_iop_to_descriptor
104 *
105 *  Macro to convert an internal file descriptor pointer (iop) into
106 *  the integer file descriptor used by the "section 2" system calls.
107 */
108
109#define rtems_libio_iop_to_descriptor(_iop) \
110  ((_iop) - &rtems_libio_iops[0])
111
112/*
113 *  rtems_libio_check_is_open
114 *
115 *  Macro to check if a file descriptor is actually open.
116 */
117
118#define rtems_libio_check_is_open(_iop) \
119  do {                                               \
120      if (((_iop)->flags & LIBIO_FLAGS_OPEN) == 0) { \
121          errno = EBADF;                             \
122          return -1;                                 \
123      }                                              \
124  } while (0)
125
126/*
127 *  rtems_libio_check_fd
128 *
129 *  Macro to check if a file descriptor number is valid.
130 */
131
132#define rtems_libio_check_fd(_fd) \
133  do {                                                     \
134      if ((uint32_t) (_fd) >= rtems_libio_number_iops) {   \
135          errno = EBADF;                                   \
136          return -1;                                       \
137      }                                                    \
138  } while (0)
139
140/*
141 *  rtems_libio_check_buffer
142 *
143 *  Macro to check if a buffer pointer is valid.
144 */
145
146#define rtems_libio_check_buffer(_buffer) \
147  do {                                    \
148      if ((_buffer) == 0) {               \
149          errno = EINVAL;                 \
150          return -1;                      \
151      }                                   \
152  } while (0)
153
154/*
155 *  rtems_libio_check_count
156 *
157 *  Macro to check if a count or length is valid.
158 */
159
160#define rtems_libio_check_count(_count) \
161  do {                                  \
162      if ((_count) == 0) {              \
163          return 0;                     \
164      }                                 \
165  } while (0)
166
167/*
168 *  rtems_libio_check_permissions_with_error
169 *
170 *  Macro to check if a file descriptor is open for this operation.
171 *  On failure, return the user specified error.
172 */
173
174#define rtems_libio_check_permissions_with_error(_iop, _flag, _errno) \
175  do {                                                      \
176      if (((_iop)->flags & (_flag)) == 0) {                 \
177            rtems_set_errno_and_return_minus_one( _errno ); \
178            return -1;                                      \
179      }                                                     \
180  } while (0)
181
182/*
183 *  rtems_libio_check_permissions
184 *
185 *  Macro to check if a file descriptor is open for this operation.
186 *  On failure, return EINVAL
187 */
188
189#define rtems_libio_check_permissions(_iop, _flag) \
190   rtems_libio_check_permissions_with_error(_iop, _flag, EINVAL )
191
192/**
193 * @brief Clones a node.
194 *
195 * The caller must hold the file system instance lock.
196 *
197 * @param[out] clone The cloned location.
198 * @param[in] master The master location.
199 *
200 * @see rtems_filesystem_instance_lock().
201 */
202void rtems_filesystem_location_clone(
203  rtems_filesystem_location_info_t *clone,
204  const rtems_filesystem_location_info_t *master
205);
206
207/**
208 * @brief Releases all resources of a location.
209 *
210 * This function may block on a mutex and may complete an unmount process.
211 *
212 * @param[in] loc The location to free.
213 *
214 * @note The file system root location is released by the file system
215 * instance destruction handler (see @ref rtems_filesystem_fsunmount_me_t).
216 *
217 * @see rtems_filesystem_freenode_t.
218 */
219void rtems_filesystem_location_free( rtems_filesystem_location_info_t *loc );
220
221/*
222 *  External structures
223 */
224#include <rtems/userenv.h>
225
226void rtems_libio_free_user_env( void *env );
227
228extern pthread_key_t rtems_current_user_env_key;
229
230static inline void rtems_libio_lock( void )
231{
232  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
233}
234
235static inline void rtems_libio_unlock( void )
236{
237  rtems_semaphore_release( rtems_libio_semaphore );
238}
239
240static inline void rtems_filesystem_mt_lock( void )
241{
242  rtems_libio_lock();
243}
244
245static inline void rtems_filesystem_mt_unlock( void )
246{
247  rtems_libio_unlock();
248}
249
250extern rtems_interrupt_lock rtems_filesystem_mt_entry_lock_control;
251
252#define rtems_filesystem_mt_entry_declare_lock_context( ctx ) \
253  rtems_interrupt_lock_context ctx
254
255#define rtems_filesystem_mt_entry_lock( ctx ) \
256  rtems_interrupt_lock_acquire( &rtems_filesystem_mt_entry_lock_control, &ctx )
257
258#define rtems_filesystem_mt_entry_unlock( ctx ) \
259  rtems_interrupt_lock_release( &rtems_filesystem_mt_entry_lock_control, &ctx )
260
261static inline void rtems_filesystem_instance_lock(
262  const rtems_filesystem_location_info_t *loc
263)
264{
265  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
266
267  (*mt_entry->ops->lock_h)( mt_entry );
268}
269
270static inline void rtems_filesystem_instance_unlock(
271  const rtems_filesystem_location_info_t *loc
272)
273{
274  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
275
276  (*mt_entry->ops->unlock_h)( mt_entry );
277}
278
279/*
280 *  File Descriptor Routine Prototypes
281 */
282
283/**
284 * This routine searches the IOP Table for an unused entry.  If it
285 * finds one, it returns it.  Otherwise, it returns NULL.
286 */
287rtems_libio_t *rtems_libio_allocate(void);
288
289/**
290 * Convert UNIX fnctl(2) flags to ones that RTEMS drivers understand
291 */
292uint32_t rtems_libio_fcntl_flags( int fcntl_flags );
293
294/**
295 * Convert RTEMS internal flags to UNIX fnctl(2) flags
296 */
297int rtems_libio_to_fcntl_flags( uint32_t flags );
298
299/**
300 * This routine frees the resources associated with an IOP (file descriptor)
301 * and clears the slot in the IOP Table.
302 */
303void rtems_libio_free(
304  rtems_libio_t *iop
305);
306
307/*
308 *  File System Routine Prototypes
309 */
310
311rtems_filesystem_location_info_t *
312rtems_filesystem_eval_path_start(
313  rtems_filesystem_eval_path_context_t *ctx,
314  const char *path,
315  int eval_flags
316);
317
318rtems_filesystem_location_info_t *
319rtems_filesystem_eval_path_start_with_parent(
320  rtems_filesystem_eval_path_context_t *ctx,
321  const char *path,
322  int eval_flags,
323  rtems_filesystem_location_info_t *parentloc,
324  int parent_eval_flags
325);
326
327rtems_filesystem_location_info_t *
328rtems_filesystem_eval_path_start_with_root_and_current(
329  rtems_filesystem_eval_path_context_t *ctx,
330  const char *path,
331  size_t pathlen,
332  int eval_flags,
333  rtems_filesystem_global_location_t *const *global_root_ptr,
334  rtems_filesystem_global_location_t *const *global_current_ptr
335);
336
337void rtems_filesystem_eval_path_continue(
338  rtems_filesystem_eval_path_context_t *ctx
339);
340
341void rtems_filesystem_eval_path_cleanup(
342  rtems_filesystem_eval_path_context_t *ctx
343);
344
345void rtems_filesystem_eval_path_recursive(
346  rtems_filesystem_eval_path_context_t *ctx,
347  const char *path,
348  size_t pathlen
349);
350
351void rtems_filesystem_eval_path_cleanup_with_parent(
352  rtems_filesystem_eval_path_context_t *ctx,
353  rtems_filesystem_location_info_t *parentloc
354);
355
356/**
357 * @brief Requests a path evaluation restart.
358 *
359 * Sets the start and current location to the new start location.  The caller
360 * must terminate its current evaluation process.  The path evaluation
361 * continues in the next loop iteration within
362 * rtems_filesystem_eval_path_continue().  This avoids recursive invocations.
363 * The function obtains the new start location and clones it to set the new
364 * current location.  The previous start and current locations are released.
365 *
366 * @param[in, out] ctx The path evaluation context.
367 * @param[in, out] newstartloc_ptr Pointer to the new start location.
368 */
369void rtems_filesystem_eval_path_restart(
370  rtems_filesystem_eval_path_context_t *ctx,
371  rtems_filesystem_global_location_t **newstartloc_ptr
372);
373
374typedef enum {
375  RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE,
376  RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE,
377  RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY
378} rtems_filesystem_eval_path_generic_status;
379
380/**
381 * @brief Tests if the current location is a directory.
382 *
383 * @param[in, out] ctx The path evaluation context.
384 * @param[in, out] arg The handler argument.
385 *
386 * @retval true The current location is a directory.
387 * @retval false Otherwise.
388 *
389 * @see rtems_filesystem_eval_path_generic().
390 */
391typedef bool (*rtems_filesystem_eval_path_is_directory)(
392  rtems_filesystem_eval_path_context_t *ctx,
393  void *arg
394);
395
396/**
397 * @brief Evaluates a token.
398 *
399 * @param[in, out] ctx The path evaluation context.
400 * @param[in, out] arg The handler argument.
401 * @param[in] token The token contents.
402 * @param[in] tokenlen The token length in characters.
403 *
404 * @retval status The generic path evaluation status.
405 *
406 * @see rtems_filesystem_eval_path_generic().
407 */
408typedef rtems_filesystem_eval_path_generic_status
409(*rtems_filesystem_eval_path_eval_token)(
410  rtems_filesystem_eval_path_context_t *ctx,
411  void *arg,
412  const char *token,
413  size_t tokenlen
414);
415
416typedef struct {
417  rtems_filesystem_eval_path_is_directory is_directory;
418  rtems_filesystem_eval_path_eval_token eval_token;
419} rtems_filesystem_eval_path_generic_config;
420
421void rtems_filesystem_eval_path_generic(
422  rtems_filesystem_eval_path_context_t *ctx,
423  void *arg,
424  const rtems_filesystem_eval_path_generic_config *config
425);
426
427void rtems_filesystem_initialize(void);
428
429/**
430 * @brief Copies a location.
431 *
432 * A bitwise copy is performed.  The destination location will be added to the
433 * corresponding mount entry.
434 *
435 * @param[out] dst The destination location.
436 * @param[in] src The  source location.
437 *
438 * @retval dst The destination location.
439 *
440 * @see rtems_filesystem_location_clone().
441 */
442rtems_filesystem_location_info_t *rtems_filesystem_location_copy(
443  rtems_filesystem_location_info_t *dst,
444  const rtems_filesystem_location_info_t *src
445);
446
447static inline rtems_filesystem_location_info_t *
448rtems_filesystem_location_initialize_to_null(
449  rtems_filesystem_location_info_t *loc
450)
451{
452  return rtems_filesystem_location_copy(
453    loc,
454    &rtems_filesystem_global_location_null.location
455  );
456}
457
458rtems_filesystem_global_location_t *
459rtems_filesystem_location_transform_to_global(
460  rtems_filesystem_location_info_t *loc
461);
462
463/**
464 * @brief Assigns a global file system location.
465 *
466 * @param[in, out] lhs_global_loc_ptr Pointer to the global left hand side file
467 * system location.  The current left hand side location will be released.
468 * @param[in] rhs_global_loc The global right hand side file system location.
469 */
470void rtems_filesystem_global_location_assign(
471  rtems_filesystem_global_location_t **lhs_global_loc_ptr,
472  rtems_filesystem_global_location_t *rhs_global_loc
473);
474
475/**
476 * @brief Obtains a global file system location.
477 *
478 * Deferred releases will be processed in this function.
479 *
480 * This function must be called from normal thread context and may block on a
481 * mutex.  Thread dispatching is disabled to protect some critical sections.
482 *
483 * @param[in] global_loc_ptr Pointer to the global file system location.
484 *
485 * @return A global file system location.  It returns always a valid object.
486 * In case of an error, the global null location will be returned.  Each
487 * operation or handler of the null location returns an error status.  The
488 * errno indicates the error.  The NULL pointer is never returned.
489 *
490 * @see rtems_filesystem_location_transform_to_global(),
491 * rtems_filesystem_global_location_obtain_null(), and
492 * rtems_filesystem_global_location_release().
493 */
494rtems_filesystem_global_location_t *rtems_filesystem_global_location_obtain(
495  rtems_filesystem_global_location_t *const *global_loc_ptr
496);
497
498/**
499 * @brief Releases a global file system location.
500 *
501 * In case the reference count reaches zero, all associated resources will be
502 * released.  This may include the complete unmount of the corresponding file
503 * system instance.
504 *
505 * This function may block on a mutex.  It may be called within critical
506 * sections of the operating system.  In this case the release will be
507 * deferred.  The next obtain call will do the actual release.
508 *
509 * @param[in] global_loc The global file system location.  It must not be NULL.
510 * @param[in] deferred If true, then do a deferred release, otherwise release
511 *   it immediately.
512 *
513 * @see rtems_filesystem_global_location_obtain().
514 */
515void rtems_filesystem_global_location_release(
516  rtems_filesystem_global_location_t *global_loc,
517  bool deferred
518);
519
520void rtems_filesystem_location_detach(
521  rtems_filesystem_location_info_t *detach
522);
523
524void rtems_filesystem_location_copy_and_detach(
525  rtems_filesystem_location_info_t *copy,
526  rtems_filesystem_location_info_t *detach
527);
528
529static inline rtems_filesystem_global_location_t *
530rtems_filesystem_global_location_obtain_null(void)
531{
532  rtems_filesystem_global_location_t *global_loc = NULL;
533
534  return rtems_filesystem_global_location_obtain( &global_loc );
535}
536
537static inline bool rtems_filesystem_location_is_null(
538  const rtems_filesystem_location_info_t *loc
539)
540{
541  return loc->handlers == &rtems_filesystem_null_handlers;
542}
543
544static inline bool rtems_filesystem_global_location_is_null(
545  const rtems_filesystem_global_location_t *global_loc
546)
547{
548  return rtems_filesystem_location_is_null( &global_loc->location );
549}
550
551static inline void rtems_filesystem_location_error(
552  const rtems_filesystem_location_info_t *loc,
553  int eno
554)
555{
556  if ( !rtems_filesystem_location_is_null( loc ) ) {
557    errno = eno;
558  }
559}
560
561int rtems_filesystem_mknod(
562  const rtems_filesystem_location_info_t *parentloc,
563  const char *name,
564  size_t namelen,
565  mode_t mode,
566  dev_t dev
567);
568
569int rtems_filesystem_chdir( rtems_filesystem_location_info_t *loc );
570
571int rtems_filesystem_chmod(
572  const rtems_filesystem_location_info_t *loc,
573  mode_t mode
574);
575
576int rtems_filesystem_chown(
577  const rtems_filesystem_location_info_t *loc,
578  uid_t owner,
579  gid_t group
580);
581
582static inline bool rtems_filesystem_is_ready_for_unmount(
583  rtems_filesystem_mount_table_entry_t *mt_entry
584)
585{
586  bool ready = !mt_entry->mounted
587    && rtems_chain_has_only_one_node( &mt_entry->location_chain )
588    && mt_entry->mt_fs_root->reference_count == 1;
589
590  if ( ready ) {
591    rtems_chain_initialize_empty( &mt_entry->location_chain );
592  }
593
594  return ready;
595}
596
597static inline void rtems_filesystem_location_add_to_mt_entry(
598  rtems_filesystem_location_info_t *loc
599)
600{
601  rtems_filesystem_mt_entry_declare_lock_context( lock_context );
602
603  rtems_filesystem_mt_entry_lock( lock_context );
604  rtems_chain_append_unprotected(
605    &loc->mt_entry->location_chain,
606    &loc->mt_entry_node
607  );
608  rtems_filesystem_mt_entry_unlock( lock_context );
609}
610
611void rtems_filesystem_location_remove_from_mt_entry(
612  rtems_filesystem_location_info_t *loc
613);
614
615void rtems_filesystem_do_unmount(
616  rtems_filesystem_mount_table_entry_t *mt_entry
617);
618
619static inline bool rtems_filesystem_location_is_instance_root(
620  const rtems_filesystem_location_info_t *loc
621)
622{
623  const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
624
625  return (*mt_entry->ops->are_nodes_equal_h)(
626    loc,
627    &mt_entry->mt_fs_root->location
628  );
629}
630
631static inline const char *rtems_filesystem_eval_path_get_path(
632  rtems_filesystem_eval_path_context_t *ctx
633)
634{
635  return ctx->path;
636}
637
638static inline size_t rtems_filesystem_eval_path_get_pathlen(
639  rtems_filesystem_eval_path_context_t *ctx
640)
641{
642  return ctx->pathlen;
643}
644
645static inline void rtems_filesystem_eval_path_set_path(
646  rtems_filesystem_eval_path_context_t *ctx,
647  const char *path,
648  size_t pathlen
649)
650{
651  ctx->path = path;
652  ctx->pathlen = pathlen;
653}
654
655static inline void rtems_filesystem_eval_path_clear_path(
656  rtems_filesystem_eval_path_context_t *ctx
657)
658{
659  ctx->pathlen = 0;
660}
661
662static inline const char *rtems_filesystem_eval_path_get_token(
663  rtems_filesystem_eval_path_context_t *ctx
664)
665{
666  return ctx->token;
667}
668
669static inline size_t rtems_filesystem_eval_path_get_tokenlen(
670  rtems_filesystem_eval_path_context_t *ctx
671)
672{
673  return ctx->tokenlen;
674}
675
676static inline void rtems_filesystem_eval_path_set_token(
677  rtems_filesystem_eval_path_context_t *ctx,
678  const char *token,
679  size_t tokenlen
680)
681{
682  ctx->token = token;
683  ctx->tokenlen = tokenlen;
684}
685
686static inline void rtems_filesystem_eval_path_clear_token(
687  rtems_filesystem_eval_path_context_t *ctx
688)
689{
690  ctx->tokenlen = 0;
691}
692
693static inline void rtems_filesystem_eval_path_put_back_token(
694  rtems_filesystem_eval_path_context_t *ctx
695)
696{
697  size_t tokenlen = ctx->tokenlen;
698
699  ctx->path -= tokenlen;
700  ctx->pathlen += tokenlen;
701  ctx->tokenlen = 0;
702}
703
704void rtems_filesystem_eval_path_eat_delimiter(
705  rtems_filesystem_eval_path_context_t *ctx
706);
707
708void rtems_filesystem_eval_path_next_token(
709  rtems_filesystem_eval_path_context_t *ctx
710);
711
712static inline void rtems_filesystem_eval_path_get_next_token(
713  rtems_filesystem_eval_path_context_t *ctx,
714  const char **token,
715  size_t *tokenlen
716)
717{
718  rtems_filesystem_eval_path_next_token(ctx);
719  *token = ctx->token;
720  *tokenlen = ctx->tokenlen;
721}
722
723static inline rtems_filesystem_location_info_t *
724rtems_filesystem_eval_path_get_currentloc(
725  rtems_filesystem_eval_path_context_t *ctx
726)
727{
728  return &ctx->currentloc;
729}
730
731static inline bool rtems_filesystem_eval_path_has_path(
732  const rtems_filesystem_eval_path_context_t *ctx
733)
734{
735  return ctx->pathlen > 0;
736}
737
738static inline bool rtems_filesystem_eval_path_has_token(
739  const rtems_filesystem_eval_path_context_t *ctx
740)
741{
742  return ctx->tokenlen > 0;
743}
744
745static inline int rtems_filesystem_eval_path_get_flags(
746  const rtems_filesystem_eval_path_context_t *ctx
747)
748{
749  return ctx->flags;
750}
751
752static inline void rtems_filesystem_eval_path_set_flags(
753  rtems_filesystem_eval_path_context_t *ctx,
754  int flags
755)
756{
757  ctx->flags = flags;
758}
759
760static inline void rtems_filesystem_eval_path_clear_and_set_flags(
761  rtems_filesystem_eval_path_context_t *ctx,
762  int clear,
763  int set
764)
765{
766  int flags = ctx->flags;
767
768  flags &= ~clear;
769  flags |= set;
770
771  ctx->flags = flags;
772}
773
774static inline void rtems_filesystem_eval_path_extract_currentloc(
775  rtems_filesystem_eval_path_context_t *ctx,
776  rtems_filesystem_location_info_t *get
777)
778{
779  rtems_filesystem_location_copy_and_detach(
780    get,
781    &ctx->currentloc
782  );
783}
784
785void rtems_filesystem_eval_path_error(
786  rtems_filesystem_eval_path_context_t *ctx,
787  int eno
788);
789
790/**
791 * @brief Checks that the locations exist in the same file system instance.
792 *
793 * @retval 0 The locations exist and are in the same file system instance.
794 * @retval -1 An error occurred.  The @c errno indicates the error.
795 */
796int rtems_filesystem_location_exists_in_same_instance_as(
797  const rtems_filesystem_location_info_t *a,
798  const rtems_filesystem_location_info_t *b
799);
800
801/**
802 * @brief Checks if access to an object is allowed for the current user.
803 *
804 * If the effective UID is zero or equals the UID of the object, then the user
805 * permission flags of the object will be used.  Otherwise if the effective GID
806 * is zero or equals the GID of the object or one of the supplementary group
807 * IDs is equal to the GID of the object, then the group permission flags of
808 * the object will be used.  Otherwise the other permission flags of the object
809 * will be used.
810 *
811 * @param[in] flags The flags determining the access type.  It can be
812 *   RTEMS_FS_PERMS_READ, RTEMS_FS_PERMS_WRITE or RTEMS_FS_PERMS_EXEC.
813 * @param[in] object_mode The mode of the object specifying the permission flags.
814 * @param[in] object_uid The UID of the object.
815 * @param[in] object_gid The GID of the object.
816 *
817 * @retval true Access is allowed.
818 * @retval false Otherwise.
819 */
820bool rtems_filesystem_check_access(
821  int flags,
822  mode_t object_mode,
823  uid_t object_uid,
824  gid_t object_gid
825);
826
827bool rtems_filesystem_eval_path_check_access(
828  rtems_filesystem_eval_path_context_t *ctx,
829  int eval_flags,
830  mode_t node_mode,
831  uid_t node_uid,
832  gid_t node_gid
833);
834
835static inline bool rtems_filesystem_is_delimiter(char c)
836{
837  return c == '/' || c == '\\';
838}
839
840static inline bool rtems_filesystem_is_current_directory(
841  const char *token,
842  size_t tokenlen
843)
844{
845  return tokenlen == 1 && token [0] == '.';
846}
847
848static inline bool rtems_filesystem_is_parent_directory(
849  const char *token,
850  size_t tokenlen
851)
852{
853  return tokenlen == 2 && token [0] == '.' && token [1] == '.';
854}
855
856static inline ssize_t rtems_libio_iovec_eval(
857  int fd,
858  const struct iovec *iov,
859  int iovcnt,
860  uint32_t flags,
861  rtems_libio_t **iopp
862)
863{
864  ssize_t        total;
865  int            v;
866  rtems_libio_t *iop;
867
868  rtems_libio_check_fd( fd );
869  iop = rtems_libio_iop( fd );
870  rtems_libio_check_is_open( iop );
871  rtems_libio_check_permissions_with_error( iop, flags, EBADF );
872
873  *iopp = iop;
874
875  /*
876   *  Argument validation on IO vector
877   */
878  if ( iov == NULL )
879    rtems_set_errno_and_return_minus_one( EINVAL );
880
881  if ( iovcnt <= 0 )
882    rtems_set_errno_and_return_minus_one( EINVAL );
883
884  if ( iovcnt > IOV_MAX )
885    rtems_set_errno_and_return_minus_one( EINVAL );
886
887  /*
888   *  OpenGroup says that you are supposed to return EINVAL if the
889   *  sum of the iov_len values in the iov array would overflow a
890   *  ssize_t.
891   */
892  total = 0;
893  for ( v = 0 ; v < iovcnt ; ++v ) {
894    size_t len = iov[ v ].iov_len;
895
896    if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
897      rtems_set_errno_and_return_minus_one( EINVAL );
898    }
899
900    total += ( ssize_t ) len;
901
902    if ( iov[ v ].iov_base == NULL && len != 0 ) {
903      rtems_set_errno_and_return_minus_one( EINVAL );
904    }
905  }
906
907  return total;
908}
909
910/**
911 * @brief Returns the file type of the file referenced by the filesystem
912 * location.
913 *
914 * @brief[in] loc The filesystem location.
915 *
916 * @return The type of the file or an invalid file type in case of an error.
917 */
918static inline mode_t rtems_filesystem_location_type(
919  const rtems_filesystem_location_info_t *loc
920)
921{
922  struct stat st;
923
924  st.st_mode = 0;
925  (void) ( *loc->handlers->fstat_h )( loc, &st );
926
927  return st.st_mode;
928}
929
930/** @} */
931
932#ifdef __cplusplus
933}
934#endif
935
936#endif
937/* end of include file */
Note: See TracBrowser for help on using the repository browser.