VirtualBox

Changeset 101903 in vbox


Ignore:
Timestamp:
Nov 6, 2023 8:57:45 PM (15 months ago)
Author:
vboxsync
Message:

libs/xpcom: Remove unused code from nsprpub, bugref:10545

Location:
trunk/src/libs/xpcom18a4
Files:
1 deleted
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/libs/xpcom18a4/Makefile.kmk

    r101891 r101903  
    180180        nsprpub/pr/include/prinrval.h \
    181181        nsprpub/pr/include/prio.h \
    182         nsprpub/pr/include/pripcsem.h \
    183182        nsprpub/pr/include/prlink.h \
    184183        nsprpub/pr/include/prlock.h \

  • trunk/src/libs/xpcom18a4/nsprpub/pr/include/nspr.h

    r101875 r101903  
    5151#include "prinrval.h"
    5252#include "prio.h"
    53 #include "pripcsem.h"
    5453#include "prlink.h"
    5554#include "prlock.h"

  • trunk/src/libs/xpcom18a4/nsprpub/pr/src/pthreads/ptsynch.c

    r101805 r101903  
    5858#if defined(DEBUG)
    5959extern PTDebug pt_debug;  /* this is shared between several modules */
    60 
    61 #if defined(_PR_DCETHREADS)
    62 static pthread_t pt_zero_tid;  /* a null pthread_t (pthread_t is a struct
    63                                 * in DCE threads) to compare with */
    64 #endif  /* defined(_PR_DCETHREADS) */
    6560#endif  /* defined(DEBUG) */
    6661
    … …  
    270265
    271266    /* NSPR doesn't report timeouts */
    272 #ifdef _PR_DCETHREADS
    273     if (rv == -1) return (errno == EAGAIN) ? 0 : errno;
    274     else return rv;
    275 #else
    276267    return (rv == ETIMEDOUT) ? 0 : rv;
    277 #endif
    278268}  /* pt_TimedWait */
    279269
    … …  
    678668}
    679669
    680 /*
    681  * Define the interprocess named semaphore functions.
    682  * There are three implementations:
    683  * 1. POSIX semaphore based;
    684  * 2. System V semaphore based;
    685  * 3. unsupported (fails with PR_NOT_IMPLEMENTED_ERROR).
    686  */
    687 
    688 #ifdef _PR_HAVE_POSIX_SEMAPHORES
    689 #include <fcntl.h>
    690 
    691 PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
    692     const char *name,
    693     PRIntn flags,
    694     PRIntn mode,
    695     PRUintn value)
    696 {
    697     PRSem *sem;
    698     char osname[PR_IPC_NAME_SIZE];
    699 
    700     if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
    701         == PR_FAILURE)
    702     {
    703         return NULL;
    704     }
    705 
    706     sem = PR_NEW(PRSem);
    707     if (NULL == sem)
    708     {
    709         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
    710         return NULL;
    711     }
    712 
    713     if (flags & PR_SEM_CREATE)
    714     {
    715         int oflag = O_CREAT;
    716 
    717         if (flags & PR_SEM_EXCL) oflag |= O_EXCL;
    718         sem->sem = sem_open(osname, oflag, mode, value);
    719     }
    720     else
    721     {
    722 #ifdef HPUX
    723         /* Pass 0 as the mode and value arguments to work around a bug. */
    724         sem->sem = sem_open(osname, 0, 0, 0);
    725 #else
    726         sem->sem = sem_open(osname, 0);
    727 #endif
    728     }
    729     if ((sem_t *) -1 == sem->sem)
    730     {
    731         _PR_MD_MAP_DEFAULT_ERROR(errno);
    732         PR_DELETE(sem);
    733         return NULL;
    734     }
    735     return sem;
    736 }
    737 
    738 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
    739 {
    740     int rv;
    741     rv = sem_wait(sem->sem);
    742     if (0 != rv)
    743     {
    744         _PR_MD_MAP_DEFAULT_ERROR(errno);
    745         return PR_FAILURE;
    746     }
    747     return PR_SUCCESS;
    748 }
    749 
    750 PR_IMPLEMENT(PRStatus) PR_PostSemaphore(PRSem *sem)
    751 {
    752     int rv;
    753     rv = sem_post(sem->sem);
    754     if (0 != rv)
    755     {
    756         _PR_MD_MAP_DEFAULT_ERROR(errno);
    757         return PR_FAILURE;
    758     }
    759     return PR_SUCCESS;
    760 }
    761 
    762 PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
    763 {
    764     int rv;
    765     rv = sem_close(sem->sem);
    766     if (0 != rv)
    767     {
    768         _PR_MD_MAP_DEFAULT_ERROR(errno);
    769         return PR_FAILURE;
    770     }
    771     PR_DELETE(sem);
    772     return PR_SUCCESS;
    773 }
    774 
    775 PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
    776 {
    777     int rv;
    778     char osname[PR_IPC_NAME_SIZE];
    779 
    780     if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
    781         == PR_FAILURE)
    782     {
    783         return PR_FAILURE;
    784     }
    785     rv = sem_unlink(osname);
    786     if (0 != rv)
    787     {
    788         _PR_MD_MAP_DEFAULT_ERROR(errno);
    789         return PR_FAILURE;
    790     }
    791     return PR_SUCCESS;
    792 }
    793    
    794 #elif defined(_PR_HAVE_SYSV_SEMAPHORES)
    795 
    796 #include <fcntl.h>
    797 #include <sys/sem.h>
    798 
    799 /*
    800  * From the semctl(2) man page in glibc 2.0
    801  */
    802 #if (defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)) \
    803     || defined(OPENBSD) || defined(BSDI)
    804 /* union semun is defined by including <sys/sem.h> */
    805 #else
    806 /* according to X/OPEN we have to define it ourselves */
    807 union semun {
    808     int val;
    809     struct semid_ds *buf;
    810     unsigned short  *array;
    811 };
    812 #endif
    813 
    814 /*
    815  * 'a' (97) is the final closing price of NSCP stock.
    816  */
    817 #define NSPR_IPC_KEY_ID 'a'  /* the id argument for ftok() */
    818 
    819 #define NSPR_SEM_MODE 0666
    820 
    821 PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
    822     const char *name,
    823     PRIntn flags,
    824     PRIntn mode,
    825     PRUintn value)
    826 {
    827     PRSem *sem;
    828     key_t key;
    829     union semun arg;
    830     struct sembuf sop;
    831     struct semid_ds seminfo;
    832 #define MAX_TRIES 60
    833     PRIntn i;
    834     char osname[PR_IPC_NAME_SIZE];
    835 
    836     if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
    837         == PR_FAILURE)
    838     {
    839         return NULL;
    840     }
    841 
    842     /* Make sure the file exists before calling ftok. */
    843     if (flags & PR_SEM_CREATE)
    844     {
    845         int osfd = open(osname, O_RDWR|O_CREAT, mode);
    846         if (-1 == osfd)
    847         {
    848             _PR_MD_MAP_OPEN_ERROR(errno);
    849             return NULL;
    850         }
    851         if (close(osfd) == -1)
    852         {
    853             _PR_MD_MAP_CLOSE_ERROR(errno);
    854             return NULL;
    855         }
    856     }
    857     key = ftok(osname, NSPR_IPC_KEY_ID);
    858     if ((key_t)-1 == key)
    859     {
    860         _PR_MD_MAP_DEFAULT_ERROR(errno);
    861         return NULL;
    862     }
    863 
    864     sem = PR_NEW(PRSem);
    865     if (NULL == sem)
    866     {
    867         PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
    868         return NULL;
    869     }
    870 
    871     if (flags & PR_SEM_CREATE)
    872     {
    873         sem->semid = semget(key, 1, mode|IPC_CREAT|IPC_EXCL);
    874         if (sem->semid >= 0)
    875         {
    876             /* creator of a semaphore is responsible for initializing it */
    877             arg.val = 0;
    878             if (semctl(sem->semid, 0, SETVAL, arg) == -1)
    879             {
    880                 _PR_MD_MAP_DEFAULT_ERROR(errno);
    881                 PR_DELETE(sem);
    882                 return NULL;
    883             }
    884             /* call semop to set sem_otime to nonzero */
    885             sop.sem_num = 0;
    886             sop.sem_op = value;
    887             sop.sem_flg = 0;
    888             if (semop(sem->semid, &sop, 1) == -1)
    889             {
    890                 _PR_MD_MAP_DEFAULT_ERROR(errno);
    891                 PR_DELETE(sem);
    892                 return NULL;
    893             }
    894             return sem;
    895         }
    896 
    897         if (errno != EEXIST || flags & PR_SEM_EXCL)
    898         {
    899             _PR_MD_MAP_DEFAULT_ERROR(errno);
    900             PR_DELETE(sem);
    901             return NULL;
    902         }
    903     }
    904 
    905     sem->semid = semget(key, 1, NSPR_SEM_MODE);
    906     if (sem->semid == -1)
    907     {
    908         _PR_MD_MAP_DEFAULT_ERROR(errno);
    909         PR_DELETE(sem);
    910         return NULL;
    911     }
    912     for (i = 0; i < MAX_TRIES; i++)
    913     {
    914         arg.buf = &seminfo;
    915         semctl(sem->semid, 0, IPC_STAT, arg);
    916         if (seminfo.sem_otime != 0) break;
    917         sleep(1);
    918     }
    919     if (i == MAX_TRIES)
    920     {
    921         PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
    922         PR_DELETE(sem);
    923         return NULL;
    924     }
    925     return sem;
    926 }
    927 
    928 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
    929 {
    930     struct sembuf sop;
    931 
    932     sop.sem_num = 0;
    933     sop.sem_op = -1;
    934     sop.sem_flg = 0;
    935     if (semop(sem->semid, &sop, 1) == -1)
    936     {
    937         _PR_MD_MAP_DEFAULT_ERROR(errno);
    938         return PR_FAILURE;
    939     }
    940     return PR_SUCCESS;
    941 }
    942 
    943 PR_IMPLEMENT(PRStatus) PR_PostSemaphore(PRSem *sem)
    944 {
    945     struct sembuf sop;
    946 
    947     sop.sem_num = 0;
    948     sop.sem_op = 1;
    949     sop.sem_flg = 0;
    950     if (semop(sem->semid, &sop, 1) == -1)
    951     {
    952         _PR_MD_MAP_DEFAULT_ERROR(errno);
    953         return PR_FAILURE;
    954     }
    955     return PR_SUCCESS;
    956 }
    957 
    958 PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
    959 {
    960     PR_DELETE(sem);
    961     return PR_SUCCESS;
    962 }
    963 
    964 PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
    965 {
    966     key_t key;
    967     int semid;
    968     /* On some systems (e.g., glibc 2.0) semctl requires a fourth argument */
    969     union semun unused;
    970     char osname[PR_IPC_NAME_SIZE];
    971 
    972     if (_PR_MakeNativeIPCName(name, osname, sizeof(osname), _PRIPCSem)
    973         == PR_FAILURE)
    974     {
    975         return PR_FAILURE;
    976     }
    977     key = ftok(osname, NSPR_IPC_KEY_ID);
    978     if ((key_t) -1 == key)
    979     {
    980         _PR_MD_MAP_DEFAULT_ERROR(errno);
    981         return PR_FAILURE;
    982     }
    983     if (unlink(osname) == -1)
    984     {
    985         _PR_MD_MAP_UNLINK_ERROR(errno);
    986         return PR_FAILURE;
    987     }
    988     semid = semget(key, 1, NSPR_SEM_MODE);
    989     if (-1 == semid)
    990     {
    991         _PR_MD_MAP_DEFAULT_ERROR(errno);
    992         return PR_FAILURE;
    993     }
    994     unused.val = 0;
    995     if (semctl(semid, 0, IPC_RMID, unused) == -1)
    996     {
    997         _PR_MD_MAP_DEFAULT_ERROR(errno);
    998         return PR_FAILURE;
    999     }
    1000     return PR_SUCCESS;
    1001 }
    1002 
    1003 #else /* neither POSIX nor System V semaphores are available */
    1004 
    1005 PR_IMPLEMENT(PRSem *) PR_OpenSemaphore(
    1006     const char *name,
    1007     PRIntn flags,
    1008     PRIntn mode,
    1009     PRUintn value)
    1010 {
    1011     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    1012     return NULL;
    1013 }
    1014 
    1015 PR_IMPLEMENT(PRStatus) PR_WaitSemaphore(PRSem *sem)
    1016 {
    1017     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    1018     return PR_FAILURE;
    1019 }
    1020 
    1021 PR_IMPLEMENT(PRStatus) PR_PostSemaphore(PRSem *sem)
    1022 {
    1023     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    1024     return PR_FAILURE;
    1025 }
    1026 
    1027 PR_IMPLEMENT(PRStatus) PR_CloseSemaphore(PRSem *sem)
    1028 {
    1029     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    1030     return PR_FAILURE;
    1031 }
    1032 
    1033 PR_IMPLEMENT(PRStatus) PR_DeleteSemaphore(const char *name)
    1034 {
    1035     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    1036     return PR_FAILURE;
    1037 }
    1038 
    1039 #endif /* end of interprocess named semaphore functions */
    1040 
    1041 /**************************************************************/
    1042 /**************************************************************/
    1043 /******************ROUTINES FOR DCE EMULATION******************/
    1044 /**************************************************************/
    1045 /**************************************************************/
    1046 
    1047 #include "prpdce.h"
    1048 
    1049 PR_IMPLEMENT(PRStatus) PRP_TryLock(PRLock *lock)
    1050 {
    1051     PRIntn rv = pthread_mutex_trylock(&lock->mutex);
    1052     if (rv == PT_TRYLOCK_SUCCESS)
    1053     {
    1054         PR_ASSERT(PR_FALSE == lock->locked);
    1055         lock->locked = PR_TRUE;
    1056         lock->owner = pthread_self();
    1057     }
    1058     /* XXX set error code? */
    1059     return (PT_TRYLOCK_SUCCESS == rv) ? PR_SUCCESS : PR_FAILURE;
    1060 }  /* PRP_TryLock */
    1061 
    1062 PR_IMPLEMENT(PRCondVar*) PRP_NewNakedCondVar(void)
    1063 {
    1064     PRCondVar *cv;
    1065 
    1066     if (!_pr_initialized) _PR_ImplicitInitialization();
    1067 
    1068     cv = PR_NEW(PRCondVar);
    1069     if (cv != NULL)
    1070     {
    1071         int rv;
    1072         rv = _PT_PTHREAD_COND_INIT(cv->cv, _pt_cvar_attr);
    1073         PR_ASSERT(0 == rv);
    1074         cv->lock = _PR_NAKED_CV_LOCK;
    1075     }
    1076     return cv;
    1077 }  /* PRP_NewNakedCondVar */
    1078 
    1079 PR_IMPLEMENT(void) PRP_DestroyNakedCondVar(PRCondVar *cvar)
    1080 {
    1081     int rv;
    1082     rv = pthread_cond_destroy(&cvar->cv); PR_ASSERT(0 == rv);
    1083 #if defined(DEBUG)
    1084         memset(cvar, 0xaf, sizeof(PRCondVar));
    1085 #endif
    1086     PR_DELETE(cvar);
    1087 }  /* PRP_DestroyNakedCondVar */
    1088 
    1089 PR_IMPLEMENT(PRStatus) PRP_NakedWait(
    1090     PRCondVar *cvar, PRLock *ml, PRIntervalTime timeout)
    1091 {
    1092     PRIntn rv;
    1093     PR_ASSERT(cvar != NULL);
    1094     /* XXX do we really want to assert this in a naked wait? */
    1095     PR_ASSERT(_PT_PTHREAD_MUTEX_IS_LOCKED(ml->mutex));
    1096     if (timeout == PR_INTERVAL_NO_TIMEOUT)
    1097         rv = pthread_cond_wait(&cvar->cv, &ml->mutex);
    1098     else
    1099         rv = pt_TimedWait(&cvar->cv, &ml->mutex, timeout);
    1100     if (rv != 0)
    1101     {
    1102         _PR_MD_MAP_DEFAULT_ERROR(rv);
    1103         return PR_FAILURE;
    1104     }
    1105     return PR_SUCCESS;
    1106 }  /* PRP_NakedWait */
    1107 
    1108 PR_IMPLEMENT(PRStatus) PRP_NakedNotify(PRCondVar *cvar)
    1109 {
    1110     int rv;
    1111     PR_ASSERT(cvar != NULL);
    1112     rv = pthread_cond_signal(&cvar->cv);
    1113     PR_ASSERT(0 == rv);
    1114     return PR_SUCCESS;
    1115 }  /* PRP_NakedNotify */
    1116 
    1117 PR_IMPLEMENT(PRStatus) PRP_NakedBroadcast(PRCondVar *cvar)
    1118 {
    1119     int rv;
    1120     PR_ASSERT(cvar != NULL);
    1121     rv = pthread_cond_broadcast(&cvar->cv);
    1122     PR_ASSERT(0 == rv);
    1123     return PR_SUCCESS;
    1124 }  /* PRP_NakedBroadcast */
    1125 
    1126670/* ptsynch.c */
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette