Changeset 03e5a780 in rtems


Ignore:
Timestamp:
Dec 15, 2017, 5:20:09 AM (3 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
5, master
Children:
4ac5ffbb
Parents:
8ddd92d
git-author:
Sebastian Huber <sebastian.huber@…> (12/15/17 05:20:09)
git-committer:
Sebastian Huber <sebastian.huber@…> (02/02/18 14:01:23)
Message:

NFS: Use self-contained recursive mutex

Update #2843.

Location:
cpukit
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • cpukit/include/rtems/confdefs.h

    r8ddd92d r03e5a780  
    391391    defined(CONFIGURE_FILESYSTEM_NFS)
    392392  #include <librtemsNfs.h>
    393   #if !defined(CONFIGURE_MAXIMUM_NFS_MOUNTS)
    394     #define CONFIGURE_MAXIMUM_NFS_MOUNTS 1
    395   #endif
    396393  #define CONFIGURE_FILESYSTEM_ENTRY_NFS \
    397394    { RTEMS_FILESYSTEM_TYPE_NFS, rtems_nfs_initialize }
    398   #define _CONFIGURE_SEMAPHORES_FOR_NFS ((CONFIGURE_MAXIMUM_NFS_MOUNTS * 2) + 1)
    399 #else
    400   #define _CONFIGURE_SEMAPHORES_FOR_NFS 0
    401395#endif
    402396
     
    430424    { RTEMS_FILESYSTEM_TYPE_JFFS2, rtems_jffs2_initialize }
    431425#endif
    432 
    433 /**
    434  * This computes the number of semaphores required for the various
    435  * file systems including the FIFO plugin to the IMFS.
    436  */
    437 #define _CONFIGURE_SEMAPHORES_FOR_FILE_SYSTEMS _CONFIGURE_SEMAPHORES_FOR_NFS
    438426
    439427#ifdef CONFIGURE_INIT
     
    20242012
    20252013  /*
    2026    * This macro is calculated to specify the number of Classic API
    2027    * semaphores required by the application and configured RTEMS
    2028    * capabilities.
    2029    */
    2030   #define _CONFIGURE_SEMAPHORES \
    2031     (CONFIGURE_MAXIMUM_SEMAPHORES + \
    2032       _CONFIGURE_SEMAPHORES_FOR_FILE_SYSTEMS)
    2033 
    2034   /*
    20352014   * This macro is calculated to specify the memory required for
    20362015   * Classic API Semaphores using MRSP. This is only available in
     
    20552034   * that no memory need be allocated at all for semaphores.
    20562035   */
    2057   #if _CONFIGURE_SEMAPHORES == 0
     2036  #if CONFIGURE_MAXIMUM_SEMAPHORES == 0
    20582037    #define _CONFIGURE_MEMORY_FOR_SEMAPHORES(_semaphores) 0
    20592038  #else
     
    27412720   (_CONFIGURE_MEMORY_FOR_TIMERS(CONFIGURE_MAXIMUM_TIMERS + \
    27422721    _CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER ) + \
    2743    _CONFIGURE_MEMORY_FOR_SEMAPHORES(_CONFIGURE_SEMAPHORES) + \
     2722   _CONFIGURE_MEMORY_FOR_SEMAPHORES(CONFIGURE_MAXIMUM_SEMAPHORES) + \
    27442723   _CONFIGURE_MEMORY_FOR_MESSAGE_QUEUES(CONFIGURE_MAXIMUM_MESSAGE_QUEUES) + \
    27452724   _CONFIGURE_MEMORY_FOR_PARTITIONS(CONFIGURE_MAXIMUM_PARTITIONS) + \
     
    30303009    _CONFIGURE_TASKS,
    30313010    CONFIGURE_MAXIMUM_TIMERS + _CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER,
    3032     _CONFIGURE_SEMAPHORES,
     3011    CONFIGURE_MAXIMUM_SEMAPHORES,
    30333012    CONFIGURE_MAXIMUM_MESSAGE_QUEUES,
    30343013    CONFIGURE_MAXIMUM_PARTITIONS,
     
    32933272    _CONFIGURE_MEMORY_FOR_TASKS(CONFIGURE_MAXIMUM_TASKS, 0),
    32943273    _CONFIGURE_MEMORY_FOR_TIMERS(CONFIGURE_MAXIMUM_TIMERS),
    3295     _CONFIGURE_MEMORY_FOR_SEMAPHORES(_CONFIGURE_SEMAPHORES),
     3274    _CONFIGURE_MEMORY_FOR_SEMAPHORES(CONFIGURE_MAXIMUM_SEMAPHORES),
    32963275    _CONFIGURE_MEMORY_FOR_MESSAGE_QUEUES(CONFIGURE_MAXIMUM_MESSAGE_QUEUES),
    32973276    _CONFIGURE_MEMORY_FOR_PARTITIONS(CONFIGURE_MAXIMUM_PARTITIONS),
  • cpukit/libfs/src/nfsclient/src/nfs.c

    r8ddd92d r03e5a780  
    6868#include <rtems/libio_.h>
    6969#include <rtems/seterr.h>
     70#include <rtems/thread.h>
    7071#include <string.h>
    7172#include <stdio.h>
     
    198199#endif
    199200
    200 #define MUTEX_ATTRIBUTES    (RTEMS_LOCAL           |   \
    201                             RTEMS_PRIORITY         |   \
    202                             RTEMS_INHERIT_PRIORITY |   \
    203                             RTEMS_BINARY_SEMAPHORE)
    204 
    205 #define LOCK(s)         do {                               \
    206                                                 rtems_semaphore_obtain((s),    \
    207                                                                         RTEMS_WAIT,        \
    208                                                                         RTEMS_NO_TIMEOUT); \
    209                                         } while (0)
    210 
    211 #define UNLOCK(s)       do { rtems_semaphore_release((s)); \
    212                                         } while (0)
     201#define LOCK(s)         rtems_recursive_mutex_lock(&(s))
     202
     203#define UNLOCK(s)       rtems_recursive_mutex_unlock(&(s))
    213204
    214205RTEMS_INTERRUPT_LOCK_DEFINE(static, nfs_global_lock, "NFS")
     
    10371028                bigPoolDepth   = 10;
    10381029
     1030        rtems_recursive_mutex_init(&nfsGlob.llock, "NFSl");
     1031        rtems_recursive_mutex_init(&nfsGlob.lock, "NFSm");
     1032
    10391033        /* it's crucial to zero out the 'next' pointer
    10401034         * because it terminates the xdr_entry recursion
     
    10681062        }
    10691063
    1070         status = rtems_semaphore_create(
    1071                 rtems_build_name('N','F','S','l'),
    1072                 1,
    1073                 MUTEX_ATTRIBUTES,
    1074                 0,
    1075                 &nfsGlob.llock);
    1076         if (status != RTEMS_SUCCESSFUL) {
    1077                 goto cleanup;
    1078         }
    1079 
    1080         status = rtems_semaphore_create(
    1081                 rtems_build_name('N','F','S','m'),
    1082                 1,
    1083                 MUTEX_ATTRIBUTES,
    1084                 0,
    1085                 &nfsGlob.lock);
    1086         if (status != RTEMS_SUCCESSFUL) {
    1087                 goto cleanup;
    1088         }
    1089 
    10901064        if (sizeof(ino_t) < sizeof(u_int)) {
    10911065                fprintf(stderr,
     
    11131087int                     refuse;
    11141088
    1115         if (nfsGlob.llock != 0) {
    1116                 LOCK(nfsGlob.llock);
    1117                 if ( (refuse = nfsGlob.num_mounted_fs) ) {
    1118                         fprintf(stderr,"Refuse to unload NFS; %i filesystems still mounted.\n",
    1119                                                         refuse);
    1120                         nfsMountsShow(stderr);
    1121                         /* yes, printing is slow - but since you try to unload the driver,
    1122                          * you assume nobody is using NFS, so what if they have to wait?
    1123                          */
    1124                         UNLOCK(nfsGlob.llock);
    1125                         return -1;
    1126                 }
    1127         }
    1128 
    1129         if (nfsGlob.lock != 0) {
    1130                 rtems_semaphore_delete(nfsGlob.lock);
    1131                 nfsGlob.lock = 0;
     1089        LOCK(nfsGlob.llock);
     1090        if ( (refuse = nfsGlob.num_mounted_fs) ) {
     1091                fprintf(stderr,"Refuse to unload NFS; %i filesystems still mounted.\n",
     1092                                                refuse);
     1093                nfsMountsShow(stderr);
     1094                /* yes, printing is slow - but since you try to unload the driver,
     1095                 * you assume nobody is using NFS, so what if they have to wait?
     1096                 */
     1097                UNLOCK(nfsGlob.llock);
     1098                return -1;
    11321099        }
    11331100
     
    11471114        }
    11481115
    1149         if (nfsGlob.llock != 0) {
    1150                 rtems_semaphore_delete(nfsGlob.llock);
    1151                 nfsGlob.llock = 0;
    1152         }
     1116        UNLOCK(nfsGlob.llock);
     1117
     1118        rtems_recursive_mutex_destroy(&nfsGlob.lock);
     1119        rtems_recursive_mutex_destroy(&nfsGlob.llock);
    11531120
    11541121        return 0;
     
    31393106                rtems_filesystem_current->location = old;
    31403107        }
    3141         rtems_semaphore_release(rpa->sync);
     3108        rtems_binary_semaphore_post(&rpa->sync);
    31423109        rtems_task_delete(RTEMS_SELF);
    31433110}
     
    31663133        arg.sync = 0;
    31673134
    3168         status = rtems_semaphore_create(
    3169                                         rtems_build_name('r','e','s','s'),
    3170                                         0,
    3171                                         RTEMS_SIMPLE_BINARY_SEMAPHORE,
    3172                                         0,
    3173                                         &arg.sync);
    3174 
    3175         if (RTEMS_SUCCESSFUL != status)
    3176                 goto cleanup;
     3135        rtems_binary_semaphore_init(&arg.sync, "NFSress");
    31773136
    31783137        rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &pri);
     
    31983157
    31993158        /* synchronize with the helper task */
    3200         rtems_semaphore_obtain(arg.sync, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     3159        rtems_binary_semaphore_wait(&arg.sync);
    32013160
    32023161        status = arg.status;
    32033162
    32043163cleanup:
    3205         if (arg.sync)
    3206                 rtems_semaphore_delete(arg.sync);
     3164        rtems_binary_semaphore_destroy(&arg.sync);
    32073165
    32083166        return status;
  • cpukit/libfs/src/nfsclient/src/rpcio.c

    r8ddd92d r03e5a780  
    7373#include <rtems/error.h>
    7474#include <rtems/rtems_bsdnet.h>
     75#include <rtems/thread.h>
    7576#include <stdlib.h>
    7677#include <time.h>
     
    8283#include <stdio.h>
    8384#include <errno.h>
     85#include <inttypes.h>
    8486#include <string.h>
    8587#include <netinet/in.h>
     
    200202
    201203
    202 #define MU_LOCK(mutex)          do {                                                    \
    203                                                         assert(                                                 \
    204                                                                 RTEMS_SUCCESSFUL ==                     \
    205                                                                 rtems_semaphore_obtain(         \
    206                                                                                 (mutex),                        \
    207                                                                                 RTEMS_WAIT,                     \
    208                                                                                 RTEMS_NO_TIMEOUT        \
    209                                                                                 ) );                            \
    210                                                         } while(0)
    211 
    212 #define MU_UNLOCK(mutex)        do {                                                    \
    213                                                         assert(                                                 \
    214                                                                 RTEMS_SUCCESSFUL ==                     \
    215                                                                 rtems_semaphore_release(        \
    216                                                                                 (mutex)                         \
    217                                                                                 ) );                            \
    218                                                         } while(0)
    219 
    220 #define MU_CREAT(pmutex)        do {                                                    \
    221                                                         assert(                                                 \
    222                                                                 RTEMS_SUCCESSFUL ==                     \
    223                                                                 rtems_semaphore_create(         \
    224                                                                                 rtems_build_name(       \
    225                                                                                         'R','P','C','l' \
    226                                                                                         ),                              \
    227                                                                                 1,                                      \
    228                                                                                 MUTEX_ATTRIBUTES,       \
    229                                                                                 0,                                      \
    230                                                                                 (pmutex)) );            \
    231                                                         } while (0)
    232 
    233 
    234 #define MU_DESTROY(mutex)       do {                                                    \
    235                                                         assert(                                                 \
    236                                                                 RTEMS_SUCCESSFUL ==                     \
    237                                                                 rtems_semaphore_delete(         \
    238                                                                                 mutex                           \
    239                                                                                 ) );                            \
    240                                                         } while (0)
    241 
    242 #define MUTEX_ATTRIBUTES        (RTEMS_LOCAL           |                \
    243                                                         RTEMS_PRIORITY         |                \
    244                                                         RTEMS_INHERIT_PRIORITY |                \
    245                                                         RTEMS_BINARY_SEMAPHORE)
     204#define MU_LOCK(mutex)          rtems_recursive_mutex_lock(&(mutex))
     205
     206#define MU_UNLOCK(mutex)        rtems_recursive_mutex_unlock(&(mutex))
     207
     208#define MU_CREAT(pmutex)        rtems_recursive_mutex_init((pmutex), "RPCl")
     209
     210#define MU_DESTROY(mutex)       rtems_recursive_mutex_destroy(&(mutex))
    246211
    247212#define FIRST_ATTEMPT           0x88888888 /* some time that is never reached */
     
    270235                }                                       addr;
    271236                AUTH                            *auth;
    272                 rtems_id                        authlock;               /* must MUTEX the auth object - it's not clear
     237                rtems_recursive_mutex                   authlock;               /* must MUTEX the auth object - it's not clear
    273238                                                                                         *  what is better:
    274239                                                                                         *   1 having one (MUTEXed) auth per server
     
    398363                                                                                         */
    399364#ifndef NDEBUG
    400 static rtems_id                 llock   = 0;            /* MUTEX protecting the server list */
    401 static rtems_id                 hlock   = 0;            /* MUTEX protecting the hash table and the list of servers */
    402 #endif
    403 static rtems_id                 fini    = 0;            /* a synchronization semaphore we use during
     365static rtems_recursive_mutex    llock;          /* MUTEX protecting the server list */
     366static rtems_recursive_mutex    hlock;          /* MUTEX protecting the hash table and the list of servers */
     367#endif
     368static rtems_binary_semaphore   fini    = RTEMS_BINARY_SEMAPHORE_INITIALIZER("RPCf");   /* a synchronization semaphore we use during
    404369                                                                                         * module cleanup / driver unloading
    405370                                                                                         */
     
    1022987rpcUdpCleanup(void)
    1023988{
    1024         rtems_semaphore_create(
    1025                         rtems_build_name('R','P','C','f'),
    1026                         0,
    1027                         RTEMS_DEFAULT_ATTRIBUTES,
    1028                         0,
    1029                         &fini);
    1030989        rtems_event_send(rpciod, RPCIOD_KILL_EVENT);
    1031990        /* synchronize with daemon */
    1032         rtems_semaphore_obtain(fini, RTEMS_WAIT, 5*ticksPerSec);
     991        rtems_binary_semaphore_wait_timed_ticks(&fini, 5*ticksPerSec);
    1033992        /* if the message queue is still there, something went wrong */
    1034993        if (!msgQ) {
    1035994                rtems_task_delete(rpciod);
    1036995        }
    1037         rtems_semaphore_delete(fini);
    1038996        return (msgQ !=0);
    1039997}
     
    12291187                                fprintf(stderr,"RPCIO There are still transactions circulating; I refuse to go away\n");
    12301188                                fprintf(stderr,"(1st in slot %i)\n",i);
    1231                                 rtems_semaphore_release(fini);
     1189                                rtems_binary_semaphore_post(&fini);
    12321190                        } else {
    12331191                                break;
     
    13501308#endif
    13511309                                        if ( rtems_event_send(xact->requestor, RTEMS_RPC_EVENT) ) {
    1352                                                 rtems_panic("RPCIO PANIC: requestor id was 0x%08x",
     1310                                                rtems_panic("RPCIO PANIC: requestor id was 0x%08" PRIx32,
    13531311                                                                        xact->requestor);
    13541312                                        }
     
    15281486        fprintf(stderr,"RPC daemon exited...\n");
    15291487
    1530         rtems_semaphore_release(fini);
     1488        rtems_binary_semaphore_post(&fini);
    15311489        rtems_task_suspend(RTEMS_SELF);
    15321490}
Note: See TracChangeset for help on using the changeset viewer.