开源鸿蒙 POSIX Support
POSIX Support
Basic Concepts
The OpenHarmony kernel uses the musl libc library and self-developed APIs and supports the Portable Operating System Interface (POSIX). You can develop components and applications working on the kernel based on the POSIX.
Development Guidelines
Available APIs
Table 1 Available APIs
Category | Header File | API | Description |
---|---|---|---|
process | #include |
void abort(void); | Terminates the thread. |
#include |
void assert(scalar expression); | Terminates the thread if the assertion is false. | |
#include |
int pthread_cond_destroy(pthread_cond_t *cond); | Destroys a condition variable. | |
#include |
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr); | Initializes a condition variable. | |
#include |
int pthread_condattr_getpshared(const pthread_condattr_t *attr, int *shared); | Obtains condition variable attributes. Currently, only the attributes of PTHREAD_PROCESS_PRIVATE can be obtained. | |
#include |
int pthread_condattr_setpshared(pthread_condattr_t *attr, int shared); | Sets a condition variable attribute. | |
#include |
int pthread_condattr_getclock(const pthread_condattr_t *attr, clockid_t *clock); | Obtains the thread clock. | |
#include |
int pthread_condattr_destroy(pthread_condattr_t *attr); | Destroys a condition variable and invalidates the attribute object. | |
#include |
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime); | Waits for the condition. | |
#include |
int pthread_condattr_init(pthread_condattr_t *attr); | Initializes the condition variable attribute. | |
#include |
int pthread_mutex_unlock(pthread_mutex_t *mutex); | Unlocks a mutex. | |
#include |
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); | Creates a thread. | |
#include |
int pthread_join(pthread_t thread, void **retval); | Waits for a thread to terminate. | |
#include |
pthread_t pthread_self(void); | Obtains the ID of the current thread. | |
#include |
int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param); | Obtains the scheduling policy and parameters of a thread. | |
#include |
int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param); | Sets a scheduling policy and parameters for a thread. | |
#include |
int pthread_setschedprio(pthread_t thread, int prio); | Sets the thread priority. | |
#include |
int pthread_once(pthread_once_t *onceControl, void (*initRoutine)(void)); | Performs one-time initialization routine. | |
#include |
int pthread_setcancelstate(int state, int *oldState); | Sets the cancel switch for the thread. | |
#include |
int pthread_setcanceltype(int type, int *oldType); | Sets the thread cancel type. | |
#include |
int pthread_cancel(pthread_t thread); | Cancels a thread. Currently, a thread can be cancelled only by setting the PTHREAD_CANCEL_ASYNCHRONOUS status and then calling pthread_cancel. | |
#include |
void pthread_testcancel(void); | Cancels this thread. | |
#include |
int pthread_equal(pthread_t thread1, pthread_t thread2); | Checks whether the two thread IDs are equal. | |
#include |
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *outType); | Obtains the mutex type attribute. | |
#include |
int pthread_mutex_init(pthread_mutex_t *restrict m, const pthread_mutexattr_t *restrict a); | Initializes a mutex. | |
#include |
int pthread_mutex_lock(pthread_mutex_t *m); | Locks a mutex. | |
#include |
int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *absTimeout); | Requests a mutex (blocked only within the specified period). | |
#include |
int pthread_mutex_trylock(pthread_mutex_t *m); | Attempts to lock a mutex. | |
#include |
int pthread_mutex_destroy(pthread_mutex_t *m); | Destroys a mutex. | |
#include |
int pthread_attr_init(pthread_attr_t *attr); | Initializes a thread attribute object. | |
#include |
int pthread_attr_destroy(pthread_attr_t *attr); | Destroys a thread attribute object. | |
#include |
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize); | Obtains the stack size of a thread attribute object. | |
#include |
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); | Sets the stack size for a thread attribute object. | |
#include |
int pthread_attr_setstack(pthread_attr_t *attr, void *stackAddr, size_t stackSize); | Sets the stack attribute for a thread attribute object (not implemented yet). | |
#include |
int pthread_attr_getstack(const pthread_attr_t *attr, void **stackAddr, size_t *stackSize); | Obtains the stack of a thread attribute object (not implemented yet). | |
#include |
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param); | Obtains scheduling parameter attributes of a thread attribute object. | |
#include |
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param); | Sets scheduling parameter attributes for a thread attribute object. | |
#include |
int pthread_getname_np(pthread_t pthread, char *name, size_t len); | Obtains the thread name. | |
#include |
int pthread_setname_np(pthread_t pthread, const char *name); | Sets the thread name. | |
#include |
int pthread_cond_broadcast(pthread_cond_t *c); | Unblocks all threads that are currently blocked on the condition variable cond. | |
#include |
int pthread_cond_signal(pthread_cond_t *c); | Unblocks a thread. | |
#include |
int pthread_cond_wait(pthread_cond_t *restrict c, pthread_mutex_t *restrict m); | Waits for the condition. | |
fs | #include |
char *dirname(char *path); | Obtains the directory name. |
#include |
struct dirent *readdir(DIR *dirp); | Reads a directory. | |
#include |
int stat(const char *restrict path, struct stat *restrict buf); | Obtains file information. | |
#include |
int unlink(const char *pathname); | Deletes a file. | |
#include int open(const char *path, int oflags, …); |
Opens a file. If the file does not exist, create a file and open it. |
| |
#include |
int close(int fd); | Closes a file. | |
#include |
int rename(const char *oldpath, const char *newpath); | Renames a file. | |
#include |
DIR *opendir(const char *dirname); | Opens the specified directory. | |
#include |
int closedir(DIR *dir); | Closes the specified directory. | |
#include |
int mount(const char *source, const char *target, const char *filesystemtype, unsigned long mountflags, const void *data); | Mounts a file system. | |
#include |
int umount(const char *target); | Unmounts a file system. | |
#include |
int umount2(const char *target, int flag); | Unmounts a file system. | |
#include |
int fsync(int fd); | Synchronizes the file associated with the specified file descriptor to the storage device. | |
#include |
int mkdir(const char *pathname, mode_t mode); | Creates a directory. | |
#include |
int rmdir(const char *path); | Deletes a directory. | |
#include |
int fstat(int fd, struct stat *buf); | Obtains file status. | |
#include |
int statfs(const char *path, struct statfs *buf); | Obtains the file system information for a file in a specified path. | |
time | #include |
int gettimeofday(struct timeval *tv, struct timezone *tz); | Obtains the time. Currently, time zone is not supported, and the return value of tz is empty. |
#include |
struct tm *gmtime(const time_t *timep); | Converts the date and time to broken-down time or ASCII. | |
#include |
struct tm *localtime(const time_t *timep); | Obtains the local time. | |
#include |
struct tm *localtime_r(const time_t *timep, struct tm *result); | Obtains the local time. | |
#include |
time_t mktime(struct tm *tm); | Converts the date and time to broken-down time or ASCII. | |
#include |
size_t strftime(char *s, size_t max, const char *format,const struct tm *tm); | Formats the date and time. | |
#include |
time_t time(time_t *tloc); | Obtains the calendar time. | |
#include |
clock_t times(struct tms *buf); | Obtains the thread time. | |
#include |
int timer_getoverrun(timer_t timerID); | Obtains the number of timer timeout times. | |
#include |
int usleep(useconds_t usec); | Goes to hibernation, in microseconds. | |
#include |
int nanosleep(const struct timespec *tspec1, struct timespec *tspec2); | Suspends the current thread till the specified time. | |
#include |
int clock_gettime(clockid_t id, struct timespec *tspec); | Obtains the clock time. | |
#include |
int timer_create(clockid_t id, struct sigevent *restrict evp, timer_t *restrict t); | Creates a timer for a thread. | |
#include |
int timer_delete(timer_t t); | Deletes the timer for a thread. | |
#include |
int timer_settime(timer_t t, int flags, const struct itimerspec *restrict val, struct itimerspec *restrict old); | Sets a timer for a thread. | |
#include |
time_t time (time_t *t); | Obtains the time. | |
#include |
char *strptime(const char *s, const char *format, struct tm *tm); | Converts the time string into the time tm structure. | |
util | #include |
int atoi(const char *nptr); | Converts the string pointed to by nptr into an integer (int type). |
#include |
long atol(const char *nptr); | Converts the string pointed to by nptr into a long Integer (long type). | |
#include |
long long atoll(const char *nptr); | Converts the string pointed to by nptr into a long long Integer (long long type). | |
#include |
int isalnum(int c); | Checks whether the passed character is alphanumeric. | |
#include |
int isascii(int c); | Checks whether the passed character is an ASCII character. | |
#include |
int isdigit(int c); | Checks whether the passed character is a digit. | |
#include |
int islower(int c); | Checks whether the passed character is in lowercase. | |
#include |
int isprint(int c); | Checks whether the passed character is printable, including spaces. | |
#include |
int isspace(int c); | Checks whether the passed character is a white-space character. | |
#include |
int isupper(int c); | Checks whether the passed character is in uppercase. | |
#include |
int isxdigit(int c); | Checks whether the passed character is a hexadecimal number. | |
#include |
long int random (void); | Generates a pseudo-random number. | |
#include |
void srandom(unsigned int seed); | Initializes the random number generator. | |
#include |
int tolower(int c); | Converts the given letter to lowercase. | |
#include |
int toupper(int c); | Converts the given letter to uppercase. | |
#include |
type va_arg(va_list ap, type); | Retrieves the next argument in the parameter list with type. | |
#include |
void va_copy(va_list dest, va_list src); | Copies parameters. | |
#include |
void va_end(va_list ap); | Clears the variable list. | |
#include |
void va_start(va_list ap, last); | Defines the beginning of the list of variable arguments. | |
#include |
char *strchr(const char *s, int c); | Searches for the first occurrence of a character in a string. | |
#include |
int strcmp(const char *s1, const char *s2); | Compares two strings. | |
#include |
size_t strcspn(const char *s, const char *reject); | Obtains the length of the initial segment of the string s which does not contain any of bytes in the string reject. | |
#include |
char *strdup(const char *s); | Copies a string to a new position. | |
#include |
size_t strlen(const char *s); | Obtains the length of a string. | |
#include |
int strncasecmp(const char *s1, const char *s2, size_t n); | Compares the bytes of the specified length in two strings, ignoring case. | |
#include |
int strcasecmp(const char *s1, const char *s2); | Compares two strings, ignoring case. | |
#include |
int strncmp(const char *s1, const char *s2, size_t n); | Compares the bytes of the specified length in two strings. | |
#include |
char *strrchr(const char *s, int c); | Searches for the last occurrence of a character in a string. | |
#include |
char *strstr(const char *haystack, const char *needle); | Searches for the specified substring in a string. | |
#include |
long int strtol(const char *nptr, char **endptr, int base); | Converts the string pointed to by nptr into a long int value according to the given base. | |
#include |
unsigned long int strtoul(const char *nptr, char **endptr, int base); | Converts the string pointed to by nptr into an unsigned long int value according to the given base. | |
#include |
unsigned long long int strtoull(const char *nptr, char **endptr,int base); | Converts the string pointed to by nptr into an unsigned long long int value according to the given base. | |
#include |
int regcomp(regex_t *preg, const char *regex, int cflags); | Compiles a regular expression. | |
#include |
int regexec(const regex_t *preg, const char *string, size_t nmatch,regmatch_t pmatch[], int eflags); | Executes the compiled regular expression. | |
#include |
void regfree(regex_t *preg); | Releases the regular expression. | |
#include |
char *strerror(int errnum); | Obtains an error message string of the specified error code. | |
math | #include |
int abs(int i); | Obtains the absolute value. |
#include |
double log(double x); | Obtains the natural logarithm (base-e logarithm) of x. | |
#include |
double pow(double x, double y); | Obtains x raised to the power of y. | |
#include |
double round(double x); | Rounds off the value from zero to the nearest integer. | |
#include |
double sqrt(double x); | Obtains the square root of x. | |
IO | #include |
void clearerr(FILE *stream); | Clears the file end and error indication of a stream. |
#include |
int fclose(FILE *stream); | Closes a file stream. | |
#include |
FILE *fdopen(int fd, const char *mode); | Opens a file stream based on the file descriptor. | |
#include |
int feof(FILE *stream); | Checks the end-of-file indicator for a stream. | |
#include |
int fflush(FILE *stream); | Flushes a stream. | |
#include |
char *fgets(char *s, int size, FILE *stream); | Reads the next line of a stream. | |
#include |
int fileno(FILE *stream); | Obtains the file descriptor for a stream. | |
#include |
FILE *fopen(const char *path, const char *mode); | Opens a stream. | |
#include |
int fputs(const char *s, FILE *stream); | Writes a line to the specified stream. | |
#include |
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); | Reads a stream. | |
#include |
int fseek(FILE *stream, long offset, int whence); | Sets the position of the stream pointer. | |
#include |
long ftell(FILE *stream); | Obtains the position of the stream pointer. | |
#include |
size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream); | Writes data to a stream. | |
#include |
void perror(const char *s); | Prints system error information. | |
#include |
void rewind(FILE *stream); | Sets the position to the beginning of the file of the specified stream. | |
#include |
ssize_t write(int fd, const void *buf, size_t size); | Writes data a file. | |
#include |
ssize_t read(int fd, void *buf, size_t size); | Reads data from a file. | |
net | #include |
void freeaddrinfo(struct addrinfo *res); | Releases the dynamic memory allocated using getaddrinfo. |
#include |
int getaddrinfo(const char *restrict nodename,const char *restrict servname,const struct addrinfo *restrict hints,struct addrinfo **restrict res); | Obtains a list of IP addresses and port numbers for the specified host and service. | |
#include |
int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen,char *restrict node, socklen_t nodelen, char *restrict service,socklen_t servicelen, int flags); | Converts a socketaddr structure to a pair of host name and service strings. | |
#include |
unsigned int if_nametoindex(const char *ifname); | Obtains the index based on the network port name. | |
#include |
in_addr_t inet_addr(const char *cp); | Converts the network host address in dotted decimal notation to binary format. | |
#include |
char *inet_ntoa(struct in_addr in); | Converts the network host address in binary format to dotted decimal notation. | |
#include |
const char *inet_ntop(int af, const void *src,char *dst, socklen_t size); | Converts the network address in binary format to text. | |
#include |
int inet_pton(int af, const char *src, void *dst); | Converts the network address in standard text format to numeric binary format. | |
#include |
int listen(int sockfd, int backlog); | Listens for connections on a socket. | |
#include |
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags); | Receives a message from a socket. Currently, only the scenario with iov of 1 is supported and ancillary messages are not supported. | |
#include |
ssize_t send(int sockfd, const void *buf, size_t len, int flags); | Sends a message on a socket. | |
#include |
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags); | Sends a message on a socket. Ancillary messages are not supported. | |
#include |
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen); | Sends a message on a socket. | |
#include |
int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen); | Sets options associated with a socket. | |
mem | #include |
int memcmp(const void *s1, const void *s2, size_t n); | Compares successive elements from two arrays until it finds elements that are different. |
#include |
void *memcpy(void *dest, const void *src, size_t n); | Copies n bytes from the source memory area pointed to by src to the destination memory area pointed to by dest. | |
#include |
void *memset(void *s, int c, size_t n); | Initializes memory. | |
#include |
void *realloc(void *ptr, size_t size); | Reallocates memory. | |
#include |
void *malloc(size_t size); | Dynamically allocates memory blocks. | |
#include |
void free(void *ptr); | Release the memory space pointed to by ptr. | |
IPC | #include |
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout); | Locks the semaphore referenced by sem as in the sem_wait() function. |
#include |
int sem_destroy(sem_t *sem); | Destroys the specified unnamed semaphore. | |
#include |
int sem_trywait(sem_t *sem); | Attempts to apply for a semaphore. | |
#include |
int sem_init(sem_t *sem, int pshared, unsigned int value); | Creates and initializes an unnamed semaphore. | |
#include |
int sem_post(sem_t *sem); | Increments the semaphore count by 1. | |
#include |
int sem_wait(sem_t *sem); | Obtains the semaphore. | |
#include |
mqd_t mq_open(const char *mqName, int openFlag, …); | Opens an existing message queue with the specified name or creates a message queue. | |
#include |
int mq_close(mqd_t personal); | Closes a message queue with the specified descriptor. | |
#include |
int mq_unlink(const char *mqName); | Deletes the message queue of the specified name. | |
#include |
int mq_send(mqd_t personal, const char *msg, size_t msgLen, unsigned int msgPrio); | Puts a message with the specified content and length into a message queue. | |
#include |
ssize_t mq_receive(mqd_t personal, char *msg, size_t msgLen, unsigned int *msgPrio); | Deletes the oldest message from a message queue and puts it in the buffer pointed to by msg_ptr. | |
#include |
int mq_timedsend(mqd_t personal, const char *msg, size_t msgLen, unsigned int msgPrio, const struct timespec *absTimeout) | Puts a message with the specified content and length into a message queue at the specified time. | |
#include |
ssize_t mq_timedreceive(mqd_t personal, char *msg, size_t msgLen, unsigned int *msgPrio, const struct timespec *absTimeout); | Obtains a message with the specified content and length from a message queue. | |
#include |
int mq_setattr(mqd_t mqdes, const struct mq_attr *restrict newattr, struct mq_attr *restrict oldattr); | Sets the message queue attributes specified by the descriptor. | |
version | #include |
const char *libc_get_version_string(void); | Obtains the libc version string. |
#include |
int libc_get_version(void); | Obtains the libc version. |
Important Notes
Error codes
C Name | Value | Description |
---|---|---|
ENOERR | 0 | Success |
EPERM | 1 | Operation not permitted |
ENOENT | 2 | No such file or directory |
ESRCH | 3 | No such process |
EINTR | 4 | Interrupted system call |
EIO | 5 | I/O error |
ENXIO | 6 | No such device or address |
E2BIG | 7 | Arg list too long |
ENOEXEC | 8 | Exec format error |
EBADF | 9 | Bad file number |
ECHILD | 10 | No child processes |
EAGAIN | 11 | Try again |
ENOMEM | 12 | Out of memory |
EACCES | 13 | Permission denied |
EFAULT | 14 | Bad address |
ENOTBLK | 15 | Block device required |
EBUSY | 16 | Device or resource busy |
EEXIST | 17 | File exists |
EXDEV | 18 | Cross-device link |
ENODEV | 19 | No such device |
ENOTDIR | 20 | Not a directory |
EISDIR | 21 | Is a directory |
EINVAL | 22 | Invalid argument |
ENFILE* | 23 | File table overflow |
EMFILE | 24 | Too many open files |
EFBIG | 27 | File too large |
ENOSPC | 28 | No space left on device |
ESPIPE | 29 | Illegal seek |
EROFS | 30 | Read-only file system |
EMLINK | 31 | Too many links |
EDOM | 33 | Math argument out of domain |
ERANGE | 34 | Math result not representable |
EDEADLK | 35 | Resource deadlock would occur |
ENAMETOOLONG | 36 | Filename too long |
ENOLCK | 37 | No record locks available |
ENOSYS | 38 | Function not implemented |
ENOTEMPTY | 39 | Directory not empty |
ELOOP | 40 | Too many symbolic links encountered |
ENOMSG | 42 | No message of desired type |
EIDRM | 43 | Identifier removed |
ELNRNG | 48 | Link number out of range |
EBADR | 53 | Invalid request descriptor |
EBADRQC | 56 | Invalid request code |
ENOSTR | 60 | Device not a stream |
ENODATA | 61 | No data available |
ETIME | 62 | Timer expired |
EPROTO | 71 | Protocol error |
EBADMSG | 74 | Not a data message |
EOVERFLOW | 75 | Value too large for defined data type |
EMSGSIZE | 90 | Message too long |
Development Example
Demo:
Creates a thread, transfers the information in the parent thread to the child thread, and prints the transferred information and the thread ID in the child thread.
#include <stdio.h>
#include <pthread.h>
pthread_t ntid;
void *ThreadFn(void *arg)
{
pthread_t tid;
while(1) {
tid = pthread_self();
printf("\n++++++++++++++ %s %s tid = %d ++++++++++++++\n", (char*)arg, __FUNCTION__, tid);
}
return ((void *)0);
}
void DemoForTest()
{
int err;
char* str = "Hello world";
err = pthread_create(&ntid, NULL, ThreadFn, (void*)str);
if(err != 0) {
printf("can't create thread\n");
}
}
The execution result of DemoForTest is as follows:
++++++++++++++ Hello world ThreadFn tid = 48 ++++++++++++++
++++++++++++++ Hello world ThreadFn tid = 48 ++++++++++++++
++++++++++++++ Hello world ThreadFn tid = 48 ++++++++++++++
你可能感兴趣的文章
0
赞
- 所属分类: 后端技术
- 本文标签:
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
8、 golang
-
9、 openharmony
-
10、 Vue中input框自动聚焦