Posix_functions.c

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int getopt(int argc, char * const argv[],const char *optstring);

extern char *optarg;
extern int optind, opterr, optopt;

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <getopt.h>

int getopt_long(int argc, char * const argv[],const char *optstring,const struct option *longopts, int *longindex);
int getopt_long_only(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <locale.h>
char* setlocale( int category, const char* locale );

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h> 

void perror(const char *str);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

char *getcwd(char *buf, size_t size);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int chdir(const char *path);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

task_struct (files) ---> files_struct (fdt) ---> fdtable (fd) --->  file * türünden bir dizi ---> file

proses kontrol block ---> betimleyici tablosu --> dosya nesneleri (Kısaca) 

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int open(const char *path, int flags, ...);


O_RDONLY
O_WRONLY
O_RDWR

S_IRUSR
S_IWUSR
S_IXUSR
S_IRGRP
S_IWGRP
S_IXGRP
S_IROTH
S_IWOTH
S_IXOTH

S_IRWXU
S_IRWXG
S_IRWXO

#define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR)
#define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP)
#define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH)

S_IRWXU             0700        
S_IRUSR             0400 
S_IWUSR             0200 
S_IXUSR             0100 
S_IRWXG             070 
S_IRGRP             040 
S_IWGRP             020 
S_IXGRP             010 
S_IRWXO             07 
S_IROTH             04 
S_IWOTH             02 
S_IXOTH             01 
S_ISUID             04000 
S_ISGID             02000 
S_ISVTX             01000

S_IRUSR        100 000 000
S_IWUSR        010 000 000
S_IXUSR        001 000 000

S_IRGRP        000 100 000
S_IWGRP        000 010 000
S_IXGRP        001 001 000

S_IROTH        000 000 100
S_IWOTH        000 010 010
S_IXOTH        001 001 001


Standart C fopen                    POSIX
"w"                                 O_WRONLY|O_CREAT|O_TRUNC
"w+"                                O_RDWR|O_CREAT|O_TRUNC
"r"                                 O_RDONLY
"r+"                                O_RDWR
"a"                                 O_WRONLY|O_CREAT|O_APPEND
"a+"                                O_RDWR|O_CREAT|O_APPEND

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int creat(const char *path, mode_t mode);

int creat(const char *path, mode_t mode)
{
	return open(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t nbyte);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t nbyte);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);

SEEK_SET
SEEK_CUR
SEEK_END

ör : lseek(fd, 0, SEEK_END);
    
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/stat.h>

mode_t umask(mode_t cmask);

   mode_t mode;

   mode = umask(0);
   umask(mode);
   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/stat.h>

int stat(const char *path, struct stat *buf);
int fstat(int fd, struct stat *buf);
int lstat(const char *path, struct stat *buf);

struct stat {
        dev_t     st_dev;         /* ID of device containing file */
        ino_t     st_ino;         /* Inode number */
        mode_t    st_mode;        /* File type and mode */
        nlink_t   st_nlink;       /* Number of hard links */
        uid_t     st_uid;         /* User ID of owner */
        gid_t     st_gid;         /* Group ID of owner */
        dev_t     st_rdev;        /* Device ID (if special file) */
        off_t     st_size;        /* Total size, in bytes */
        blksize_t st_blksize;     /* Block size for filesystem I/O */
        blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */

        /* Since Linux 2.6, the kernel supports nanosecond precision for the following timestamp fields.
           For the details before Linux 2.6, see NOTES. */

        struct timespec st_atim;  /* Time of last access */
        struct timespec st_mtim;  /* Time of last modification */
        struct timespec st_ctim;  /* Time of last status change */

    #define st_atime st_atim.tv_sec      /* Backward compatibility */
    #define st_mtime st_mtim.tv_sec
    #define st_ctime st_ctim.tv_sec
};

struct timespec {
time_t  tv_sec;      
long    tv_nsec;
};


S_ISBLK(m)      Blok aygıt sürücü dosyası mı? (ls -l'de 'b' dosya türü)
S_ISCHR(m)      Karakter aygıt sürücü dosyası mı? (ls -l'de 'c' dosya türü)
S_ISDIR(m)      Dizin dosyası mı? (ls -l'de 'd' dosya türü)
S_ISFIFO(m)     Boru dosyası mı? (ls -l'de 'p' dosya türü)
S_ISREG(m)      Sıradan bir disk dosyası mı? (ls -l'de '-' dosya türü)
S_ISLNK(m)      Sembolik bağlantı dosyası mı? (ls -l'de 'l' dosya türü)
S_ISSOCK(m)     Soket dosyası mı? (ls -l'de 's' dosya türü)

S_IFBLK         Blok aygıt dosyası
S_IFCHR         Karakter aygıt dosyası
S_IFIFO         Boru dosyası
S_IFREG         Sıradan disk dosyası
S_IFDIR         Dizin dosyası
S_IFLNK         Sembolik bağlantı dosyası
S_IFSOCK        Soket dosyası

S_IFMT

(mode & S_IFMT) == S_IFXXX


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


#include <stdio.h>

int remove(const char *path);       

#include <unistd.h>

int unlink(const char *path);

remove'da unlink'te aynı işi yapıyor.
remove C fonksiyonudur. unlink ise POSIX fonksionudur
    
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/stat.h>

int chmod(const char *path, mode_t mode);
int fchmod(int fd, mode_t mode);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
	#ifdef _POSIX_CHOWN_RESTRICTED
	 	printf("chown restricted\n");
	#else
		printf("chown not restricted\n");
	#endif

	return 0;
}


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int chown(const char *path, uid_t owner, gid_t group);  
int fchown(int fd, uid_t owner, gid_t group);   

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/stat.h>

int mkdir(const char *path, mode_t mode);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int rmdir(const char *path);  

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pwd.h>

struct passwd *getpwnam(const char *name);
struct passwd *getpwuid(uid_t uid);


struct passwd {
        char   *pw_name;       /* username */
        char   *pw_passwd;     /* user password */
        uid_t   pw_uid;        /* user ID */
        gid_t   pw_gid;        /* group ID */
        char   *pw_gecos;      /* user information */
        char   *pw_dir;        /* home directory */
        char   *pw_shell;      /* shell program */
};

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pwd.h>

struct passwd *getpwent(void);
void setpwent(void);
void endpwent(void);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <grp.h>

struct group *getgrnam(const char *name);
struct group *getgrgid(gid_t gid);
struct group *getgrent(void);
void setgrent(void);
void endgrent(void);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int openat(int fd, const char *path, int oflag, ...);

Fonksiyonun prototipini open fonksiyonu ile karşılaştırınız:

int open(const char *path, int oflag, ...);


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

int fchmodat(int fd, const char *path, mode_t mode, int flag);
int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag);
int fstatat(int fd, const char *restrict path, struct stat *restrict buf, int flag);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


#include <dirent.h>

DIR *opendir(const char *dirname);

DIR *fdopendir(int fd);

struct dirent *readdir(DIR *dirp);

int closedir(DIR *dirp);


struct dirent {
        ino_t          d_ino;       /* Inode number */
        off_t          d_off;       /* Not an offset; see below */
        unsigned short d_reclen;    /* Length of this record */
        unsigned char  d_type;      /* Type of file; not supported
                                        by all filesystem types */
        char           d_name[256]; /* Null-terminated filename */
};

    DT_BLK      block device
    DT_CHR      character device
    DT_DIR      directory
    DT_FIFO     named pipe (FIFO)
    DT_LNK      symbolic link
    DT_REG      regular file.
    DT_SOCK     UNIX domain socket.
    DT_UNKNOWN  Bilinmeyen bir tür

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <dirent.h>

int dirfd(DIR *dirp);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/stat.h>

int fstatat(int fd, const char *restrict path, struct stat *restrict buf, int flag);

Fonskiyonun fd parametresinin yanı sıra aynı zamanda bir flag parametresinin olduğuna dikkat ediniz. Bu parametre stat semantiğinin mi yoksa 
lstat semantiğinin mi uygulanacağını belirtmektedir. Eğer bu parametreye 0 geçilirse bu durumda stat semnatiği uygulanır Eğer bu parametreye 
AT_SYMLINK_NOFOLLOW değeri geçilirse bu durumda lstat semantiği uygulanmaktadır. AT_SYMLINK_NOFOLLOW sembolik sabiti <sys/stat.h> içerisinde değil
<fcntl.h> içerisinde bildirilmiştir. İşte biz yukarıdaki örnekte önce dizin'in betimleycisini dirfd fonksiyonu ile alıp bunu fstatat 
fonksiyonunda kullanırsak yol ifadesini düzenlememize gerek kalmaz. Aşağıdaki örnekte bu çözüm verilmiştir.

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <dirent.h>

long telldir(DIR *dirp);
void seekdir(DIR *dirp, long loc);
void rewinddir(DIR *dirp);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <dirent.h>

int alphasort(const struct dirent **d1, const struct dirent **d2);
int scandir(const char *dir, struct dirent ***namelist, int (*sel)(const struct dirent *),
	int (*compar)(const struct dirent **, const struct dirent **));  
	
int cmp(const struct **direnet1, const struct **dirent2); -> biz yazdık bunu

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#define _XOPEN_SOURCE 500

#include <ftw.h>

int nftw(const char *path, int (*fn)(const char *, const struct stat *, int, struct FTW *), int fd_limit, int flags);


FTW_CHDIR: Eğer bu bayrak belirtilirse fonksiyon her dizine geçtiğinde prosesin çalışma dizinini de o dizin olarak değiştirmektedir. 

FTW_DEPTH: Normalde dolaşım "pre-order" biçimde yapılmaktadır. Bu bayrak girilirse "post-order" dolaşım yapılır. Bayrağın ismi 
yanlış 	verilmiştir. "pre-order" dolaşım demek bir dizin ile karşılaşıldığında önce dizin girişinin ele alnıması sonra özyineleme
yapılması demektir. "post-order" dolaşım ise önce özyineleme yapılıp sonra dizin girişinin ele alınması demektir.
Default durum "pre-order" dolaşım biçimindedir. 

FTW_MOUNT: Bu bayrak belirtilirse özyineleme yapılırken bir "mount point" ile karşılaşılırsa o dosya sistemine girilmez. Default durumda 
özyineleme sırasında bir "mount point" ile kaşılaşılırsa özyineleme o dosya sisteminin içime girilerek devam ettirilmektedir. 

FTW_PHYS:  Default durumda nftw fonksiyonu bir sembolik link dosyası ile karşılaştığında linki izler ve link'in hedefine
yönelik hareket eder. Daha önce bir böyle bir durumun sonsuz döngüye yol açabileceğinden bahsetmiştik. Bu nedenle biz özyinelemede 
stat fonksiyonu yerine lstat fonksiyonunu kullanmıştık. İşte bu bayrak belirtilirse artık nftw fonksiyonu sembolik link dosyası
ile karşılaştığında link'i izlemez, sembolik link dosyasının kendisi hakkında bilgi verir. 





int callback(const char *path, const struct stat *finfo, int flag, struct FTW *ftw);  -> biz yazdık

	struct FTW {
		int base;
		int level;
	};

FTW_D: Bulunan giriş bir dizin girişidir.

FTW_DNR: Bulunan giriş bir dizin girişidir. Ancak bu dizin'in içi okunamamaktadır. Dolayısıyla bu dizin özyinelemede dolaşılamayacaktır.

FTW_DP: Post-order dolaşımda bir dizinle karşılaşıldığında bayrak FTW_D yerine FTW_DP olarak set edilmektedir. 

FTW_F: Bulunan dizin girişi sıradan bir dıosyadır (regular file).

FTW_NS: Bulunan dizin girişi için stat ya da lstat fonksiyonu başarısız olmuştur. Dolayısıyla fonksiyona geçirilen stat yapısı da
anlamlı değildir. 

FTW_SL: Bulunan giriş bir sembolik bağlantı dosyasına ilişkindir. Sembolik bağlantı dosyasının hedefi mevcuttur. 

FTW_SLN: Bulunan giriş bir sembolik bağlantı dosyasına ilişkindir. Sembolik bağlantı dosyasının hedefi mevcut değildir ("danging klink" durumu). 

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int link(const char *oldpath, const char *newpath);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int symlink(const char *path1, const char *path2);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int symlinkat(const char *path1, int fd, const char *path2);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

ssize_t readlink(const char *path, char *buf, size_t bufsize);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int access(const char *path, int amode) 

Fonksiyonun birinci parametresi erişim testinin yapılacağı dosyanın yol ifadesini belirtmektedir. İkinci parametresi test edilecek 
erişimi belirtir. Bu parametre aşağıdaki sembolik sabitlerin bir düzeyinde OR'lanmasıyla oluşturulabilir:

R_OK: Okuma yapılabilir mi?
W_OK: Yazma yapılabilir mi?
X_OK: Çalıştırılabilir mi?
F_OK: Dosya var mı?

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#define _GNU_SOURCE             /* See feature_test_macros(7) */
#include <unistd.h>

int euidaccess(const char *pathname, int mode);
int eaccess(const char *pathname, int mode);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int faccessat(int fd, const char *path, int amode, int flag);

Fonksiyonun birinci paraetresi ikinci parametresiyle belirtilen yol ifadesinin göreli olması durumunda aramanın yapılacağı 
dizini belirtmektedir. Son parametre 0 geçilebilir ya da AT_EACCESS geçilebilir. Bu AT_EACCESS değeri test işleminin etkin kulalnı ve grup 
id'lerine bakılarak yapılacağı anlamına gelmektedir. (Tabii ikinci parametre ile belirtilen yol ifadesi mutlak olduğunda birinci parametrede 
belirtilen dizine ilişkin betimleyici yine dikkate alınmaz. Ancak üçüncü parametreyle belirtilen bayrak dikkate alınır)

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int dup(int fildes);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int dup2(int fildes, int fildes2);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

IO yönlendirmesi kabuk üzerinden de yapılabilmektedir. Kabukta ">" sembolü 1 numaralı betimleyicinin yönlendirileceği anlamına gelmektedir.
						   
Kabuk üzerinde "<" sembolü de 0 numaralı betimleyiciyi yönlendirmektedr.						   
						   
Aslında kabukta genel olarak yönlendirme için "n>" ve "n<" sembolleri de kullanılabilmektedir. Buradaki n betimleyicinin 
numarasını belirtir. Bu sayede biz herhangi bir betimleyiciyi okuma ve yazma amaçlı bir dosyaya yönlendirebiliriz.
ÖR: ./sample 2> test.txt

Tabii hem stdout dosyasını hem de stdin dosyasını kabuk üzerinden birlikte de yönlendirebiliriz. 
ÖR: ./sample > out.txt < in.txt
							   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------						   

<unistd.h> dosyasında okunabilirliği artırmak için şu sembolik sabitler bildirilmiştir:

#define STDIN_FILENO        0
#define STDOUT_FILENO       1
#define STDERR_FILENO       2

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

 IO yönlendirmesi kabuk üzerinden de yapılabilmektedir. Kabukta ">" sembolü 1 numaralı betimleyicinin yönlendirileceği anlamına gelmektedir. Örneğin:

./sample > test.txt

Bu durumda kabuk önce ">" sembolünün sağındaki dosyayı O_WRONLY|O_TRUNC modunda açar. Sonra ./sample programını çalıştırarak bu 
prosesin 1 numaralı betimleyicisini dup2 fonksiyonu ile bu dosyaya yönlendirir. Böylece ./sample sample programının ekrana yazdığını
zannettiği ieşyle bu dosyaya yazılmış olacaktır. 

ls gibi, cat gibi kabuk komutlarının da aslında birer program olduğuna bunların da 1 numaralı betimleyiciyi kullanarak yazdırma 
yaptığına dikkat ediniz. Örneğimn biz kabuk üzerinde şu komutu uygulayabiliriz:

ls -l > test.txt

Eğer kabulta ">" yerine ">>" sembolü kullanılırsa bu durumda ">>" sembolünün sağındaki dosya O_CREAT|O_WRONLY|O_APPEND modunda 
açılmaktadır. Yani dosya varsa bu durumda olan dosyanın sonuna ekleme yapılacaktır. Örneğin:

ls -l >> test.txt						   

Kabuk üzerinde "<" sembolü de 0 numaralı betimleyiciyi yönlendirmektedr. Örneğin:

./sample < test.txt

Burada kabuk "test.txt" dosyasını O_RDONLY modda açar. Sonra ./sample programını çalıştırır. Prosesin 0 numaralı betimleyicisini
"test.txt" dosyasına dup2 fonksiyonuyla yönlendirir. Böylece rpogram sanki klavyeden okuduğunu sanırken aslında dosyadan okuma
yapacaktır.


Aslında kabukta genel olarak yönlendirme için "n>" ve "n<" sembolleri de kullanılabilmektedir. Buradaki n betimleyicinin 
numarasını belirtir. Bu sayede biz herhangi bir betimleyiciyi okuma ve yazma amaçlı bir dosyaya yönlendirebiliriz. Örneğin:

./sample 2> test.txt

Burada "test.txt" dosyası açılıp ./sample programının "stderr" olarak isimlendirilen 2 numaralı betimleyicisi bu dosyaya 
yönlendirilecektir. 

Kabuk programları ">", "<", "n>" "n<" gibi yönlendirmeleri nasıl yapmaktadır? Bu konu ileride ele alınacaktır. Kabuk önce bir kez
fork işlemi yapar. Sonra yönlendirme işlemini gerçekleştirir. Sonra da exec işlemi yapmaktadır.
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

Komut satırındaki diğer önemli bir işlem de "boru (pipe)" işlemidir. Boru işlemi "|" ile temsil edilmektedir. Kabul üzerinden
aşağıdaki gibi bir komut uygulamış olalım:

a | b

Burada kabuk bu yazıyı "|" karakterindne parse eder. "|" karakterinin solundaki ve sağındakileri birer program olarak ele alır. 
Her iki programı da çalışırır. Yani burada "a" programı da "b" programı da çalıştırılacaktır. "a" programının "stdout" dosyasına
yazdıklarını "b" programı "stdin" dosyasından okuyacaktır. Başka bir deyişle "a" programının 1 numaralı betimeyiciyle yaptuığı write 
işlemlerini "b" programı 0 numaralı betimleyici ile read fonksiyonunu kullanarak okuyabilecektir. Kabuk boru işlemlerini
"prosesler arası haberleşme yöntemlerindne biri olan boru haberleşmesi ile" gerçekleştirmektedir. Zaten ilerleyen bölümlerde 
bu konu ele alınacaktır. 

Tabii boru işlemi yapılırken programların komut satırı arümanları da verilebilir. Örneğin:

a b c | d e f

Burada aslında çalıştırılacak programlar "a" ve "d" programlarıdır. Diğerleri bunların komut satırı argümanlarıdır. 

Aşağıdaki örnekte "a" programı ekrana (stdout dosyasına) 0'dan 10'a kadar sayıları yazdırmaktadır. "b" programı ise
döngü içerisinde klavyeden (stdin dosyasından) değer okuyup ekrana yazdırmaktadır. Bu iki programı aşağıdkai gibi çalıştıralım:

./a | ./b
						   
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>

int fileno(FILE *stream);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>

FILE *fdopen(int fd, const char *mode);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>

void setbuf(FILE *stream, char *buf);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>

int setvbuf(FILE *stream, char *buf, int mode, size_t size);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

void clear_stdin(void)
{
	int ch;
	while ((ch = getchar()) != '\n' && ch != EOF)
	    ;
}

						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>

int getchar(void);
char *gets(char *s);
char *gets_s(char *s, rsize_t n);
char *fgets(char *s, size_t n, FILE *f);
int scanf(const char *format, ...);
int getc(FILE *stream);
int ungetc(int c, FILE *stream);

						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

pid_t getpid(void);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


#include <unistd.h>

pid_t getppid(void);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

pid_t fork(void);    				   

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

void _exit(int status);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdlib.h>

void exit(int status);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
						   
#include <sys/wait.h>

pid_t wait(int *wstatus);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/wait.h>

pid_t waitpid(pid_t pid, int *stat_loc, int options);

Fonksiyonun birinci parametresi beklenecek alt prosesin proses id değerini belirtir. Bu sayede programcı belli bir alt prosesi bekleyebilmektedir. 
Bu birinci parametre aslına birkaç biçimde geçilebilmektedir. Eğer bu parametre negatif bir proses id değeri olarak geçilirse 
bu durumda fonksiyon proses grup id'si bu değerin pozitifi olan herhangi bir alt prosesi beklemektedir. Eğer bu parametre -1 
olarak geçilirse bu durumda fonksiyon tamamen wait fonksiyonundaki gibi davranmaktadır. Yani herhangi bir alt prosesi beklemektedir.
Eğer bu parametre 0 olarak geçilirse fonksiyon proses grup id'si waitpid fonksiyonunu çağıran prosesin id'si ile yanı olan 
herhangi bir alt prosesi beklemektedir. Tabii normal olarak bu parametreye programcı pozitif olan bir proses id geçer. Bu durumda
fonksiyon  o alt prosesi bekleyecektir. (Tabii bu parametreye geçilen proses id o prosesin bir alt prosesi değilse fonksiyon yine
başarısız olmaktadır.) Fonksiyonun ikinci parametresi exit bilgisinin yerleştirileceği int türden nesnesnin adresini alır. Üçüncü 
parametre bazı özel değerlerin bit düzeyinde OR'lanmasıyla oluşturulabilmektedir:

WNOHANG: Bu durumda waitpid eğer alt proses henüz sonlanmamışsa bekleme yapmaz, başarısızlıkla sonuçlanır. 
WCONTINUED, WUNTRACED: Bu bayrakların açıklaması burada yapılmayacaktır. 

Tabii bu üçüncü parametre genellikle 0 geçilmektedir. 0 geçilmesi bu bayraklardan hiçbirinin kullanılmayacağı anlamına gelmektedir. 
O halde aslında wait(&status) çağrısı ile waitpid(-1, &status, 0) eşdeğerdir. 

waitpid fonksiyonunda da ikinci parametre NULL adres geçilebilir. Bu durumda proses beklenir ama exit bilgileri elde edilmez. 

waitpid fonksiyonu da başarı durumunda beklenen proses id değeri ile başarısızlık durumunda -1 değeriyle geri dönmektedir. 

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
						   
#include <stdlib.h>

extern char **environ;
						   
char *getenv(const char *name);
					
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
						   
#include <stdlib.h>

int setenv(const char *name, const char *value, int overwrite);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdlib.h>

int putenv(char *str);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdlib.h>

int unsetenv(const char *name);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

execl
execle
execlp
execv
execve (Linux'ta sistem fonksiyonu olarak yazılmıştır)
execvp
fexecve (Linux'ta execveat sistem fonksiyonu)						   


#include <unistd.h>

int execl(const char *path, const char *arg0, ... /*, (char *)0 */);   
int execv(const char *path, char * const *argv);	 
int execlp(const char *file, const char *arg0, ... /*, (char *)0 */);
int execvp(const char *file, char *const argv[]);
int execle(const char *path, const char *arg0, ... /*, (char *)0, char *const envp[]*/);
int execve(const char *path, char *const argv[], char *const envp[]);

pid_t vfork(void);
	 
int fexecve(int fd, char *const argv[], char *const envp[]);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

fd = open("test.txt", O_RDONLY|O_CLOEXEC); // flag farkına dikkat

if (fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC)) == -1) // flag farkına dikkat
	exit_sys("fcntl");
	 
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdlib.h>
	
int system(const char *command);
						   
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

uid_t getuid(void)
uid_t geteuid(void)

gid_t getgid(void);
gid_t getegid(void);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int setuid(uid_t uid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int seteuid(uid_t uid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int setgid(gid_t gid);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int setegid(gid_t gid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int setreuid(uid_t ruid, uid_t euid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int setregid(gid_t rgid, gid_t egid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <unistd.h>

int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <unistd.h>

int setresuid(uid_t ruid, uid_t euid, uid_t suid);
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int getgroups(int gidsetsize, gid_t grouplist[]);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <grp.h>

int setgroups(size_t size, const gid_t *list);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <grp.h>

int initgroups(const char *user, gid_t group);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <unistd.h>

int pipe(int pipefd[2]);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <stdio.h>

FILE *popen(const char *command, const char *mode);

	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	

#include <stdio.h>

int pclose(FILE *stream);

	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/stat.h>

int mkfifo(const char *path, mode_t mode);  

	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <fcntl.h>

int fcntl(int fd, int cmd, ...);

File status flag:
O_APPEND
O_DSYNC
O_NONBLOCK
O_RSYNC
O_SYNC
	
File access mode:
O_EXEC
O_RDONLY
O_RDWR
O_SEARCH
O_WRONLY

F_SETFL
F_GETFL
F_SETFD
F_GETFD

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

System 5 IPC Fonksiyonların                     POSIX IPC Fonksiyonları

msgget  (mesaj kuyruğu)                         mq_open     (mesaj kuyruğu)
shmget  (paylaşaılan bellek alanları)           shm_open    (paylaşılan bellek alanaları)
semget  (semaphore'lar)                         sem_open    (semaphore'lar)

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/msg.h>

int msgget(key_t key, int msgflg);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/msg.h>

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

struct MSG {
	long mtype;
	char msg[8192];
};
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/msg.h>

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

struct MSG {
	long mtype;
	char msg[8192];
};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


#include <sys/ipc.h>

key_t ftok(const char *path, int id);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/msg.h>

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

IPC_STAT
IPC_SET
IPC_RMID

	
struct msqid_ds {
	struct ipc_perm msg_perm;   /* Ownership and permissions */
	time_t          msg_stime;  /* Time of last msgsnd(2) */
	time_t          msg_rtime;  /* Time of last msgrcv(2) */
	time_t          msg_ctime;  /* Time of creation or last
					modification by msgctl() */
	unsigned long   msg_cbytes; /* # of bytes in queue */
	msgqnum_t       msg_qnum;   /* # number of messages in queue */
	msglen_t        msg_qbytes; /* Maximum # of bytes in queue */
	pid_t           msg_lspid;  /* PID of last msgsnd(2) */
	pid_t           msg_lrpid;  /* PID of last msgrcv(2) */
};

struct ipc_perm {
	uid_t uid;                      /* Effective UID of owner */
	gid_t gid;                      /* Effective GID of owner */
	uid_t cuid;                     /* Effective UID of creator */
	gid_t cgid;                     /* Effective GID of creator */
	unsigned short mode;            /* Permissions */
};
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


#include <mqueue.h>

mqd_t mq_open(const char *name, int oflag, ...);
	
mqd_t mq_open(const char *name, int oflag, mode_t mode, const struct mq_attr *attr);
	
struct mq_attr {
	long mq_flags;       /* Flags: 0 or O_NONBLOCK */
	long mq_maxmsg;      /* Max. # of messages on queue */
	long mq_msgsize;     /* Max. message size (bytes) */
	long mq_curmsgs;     /* # of messages currently in queue */
};	

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <mqueue.h>

int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <mqueue.h>

ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <mqueue.h>

int mq_getattr(mqd_t mqdes, struct mq_attr *attr);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <mqueue.h>

int mq_setattr(mqd_t mqdes, struct mq_attr *newattr, struct mq_attr *oldattr);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/shm.h>

void *shmat(int shmid, const void *shmaddr, int shmflg);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/shm.h>

int shmdt(const void *shmaddr);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

include <sys/shm.h>

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
	
struct ipc_perm {
	uid_t          uid;      /* Effective UID of owner */
	gid_t          gid;      /* Effective GID of owner */
	uid_t          cuid;     /* Effective UID of creator */
	gid_t          cgid;     /* Effective GID of creator */
	unsigned short mode;     /* Permissions + SHM_DEST and
				    SHM_LOCKED flags */
};

struct shmid_ds {
	struct ipc_perm shm_perm;    /* Ownership and permissions */
	size_t          shm_segsz;   /* Size of segment (bytes) */
	time_t          shm_atime;   /* Last attach time */
	time_t          shm_dtime;   /* Last detach time */
	time_t          shm_ctime;   /* Creation time/time of last
					modification via shmctl() */
	pid_t           shm_cpid;    /* PID of creator */
	pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
	shmatt_t        shm_nattch;  /* No. of current attaches */
};

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/mman.h>

int shm_open(const char *name, int oflag, mode_t mode); 

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

ftruncate
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/mman.h>

void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off);

PROT_READ
PROT_WRITE
PROT_EXEC
PROT_NONE

MAP_PRIVATE
MAP_SHARED
MAP_FIXED

mmap fonksiyonunda MAP_ANONYMOUS kullanıldığında fonksiyonun fd parametresi dikkate alınmamaktadır. Ancak MAP_ANONYMOUS bayrağını destekleyen 
diğer bazı işletim sistemlerinde bu parametrenin -1 girilmesi gerekmektedir. Bu nedenle bu parametrenin -1 olması uygundur. 
Fonksiyonun offset parametresi de dikkate alınmamaktadır. Bu parametre 0 olarak girilebilir.

MAP_ANONYMOUS bayrağı MAP_PRIVATE ya da MAP_SHAED ile birlikte kullanılmaktadır. En normal durum MAP_ANOYMOUS bayrağı ile MAP_PRIVATE
bayrağının birlikte kullanılmasıdır. Pekiyi MAP_ANONYMOUS|MAP_PRIVATE ile MAP_ANONUMOUS|MAP_SHARED arasında ne farklılık vardır?
İşte normal olarak anonymous mapping için ayrılan swap alanı başka prosesler tarafından kullanılamamaktadır. Ancak fork işlemi 
üst proses bir proses yarattığında tüm mapping alanları alt prosese aktarılmaktadır. O halde biz MAP_ANONYMOUS|MAP_SHARED 
uyguladığımızda fork yapmakdıktan sonra bunun MAP_ANONYMOUS|MAP_SHARED işleminden hiçbir farkı olmayacaktır. Ancak fork yapıldığında 
MAP_ANONYMOUS|MAP_SHARED uygulamasında üst ve alt prosesler aynı anonymous alanı paylaşacaktır. Yani örneğin üst proses buraya 
bir şey yazdığında alt proses onu görecektir. Ancak MAP_ANOBYNOUS|MAP_PRIVATE uygulamasında üst proseslerden biri alan bir 
şey yazdığında "copy on write" mekanizması devreye girecek ve yazılanı diğer proses görmeyecektir. malloc fonksiyonu da
arka planda büyük alanı mmap ile tahsis ederken MAP_ANOYMOUS|MAP_PRIVATE uygulamaktadır. 
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/mman.h>

int munmap(void *addr, size_t len);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <sys/mman.h>

int shm_unlink(const char *name);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/mman.h>

int msync(void *addr, size_t len, int flags);

MS_SYNC: Burada yön bellekten diske doğrudur. Yani biz bellek tabanlı dosyanın bellek alanında değişiklik yaptığımızda bunun
diskteki dosyaya yansıtılabilmesi için MS_SYNC kullanabiliriz. Bu bayrak aynı zamanda msync fonksiyonu geri döndüğünde flush işleminin
bittiğinin garanti edilmesini sağlamaktadır. Yani bu bayrağı kullandığımızda msync flush işlemi bitince geri dönmektedir.  

MS_ASYNC: MS_SYNC bayrağı gibidir. Ancak bu bayrakta flush işlemi başlatılıp msync fonksiyonu hemen geri dönmektedir. Yani
bu bayrakta msync geri döndüğünde flush işlemi başlatılmıştır ancak bitmiş olmak zorunda değildir. 

MS_INVALIDATE: Buradaki yön diskten belleğe doğrudur. Yani başka bir proses diskteki dosyayı güncellendiğinde bu güncellemenin
bellek tabanlı dosyanın bellek alanına yansıtılması sağlanmaktadır. 
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <sys/mman.h>

int mlock(const void *addr, size_t len);
int munlock(const void *addr, size_t len);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

int mlockall(int flags);
MCL_CURRENT: Şu anda RAM'de olan tüm sayfaların kilitleneceği anlamına gelir. 
MCL_FUTURE: Bundan sonra RAM'e alınacak tüm sayfaların kilitleneceği anlamına gelir. 
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

void pthread_exit(void *value_ptr);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_cancel(pthread_t thread);
void pthread_testcancel(void); 

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_join(pthread_t thread, void **value_ptr);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <thread.h>
int pthread_setcanceltype(int type, int *oldtype);
	
PTHREAD_CANCEL_DEFERRED
PTHREAD_CANCEL_ASYNCHRONOUS

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_setcancelstate(int state, int *oldstate);

PTHREAD_CANCEL_ENABLE
PTHREAD_CANCEL_DISABLE
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

pthread_t pthread_self(void);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_attr_init(pthread_attr_t *attr);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_attr_destroy(pthread_attr_t *attr);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

PTHREAD_CREATE_DETACHED 
PTHREAD_CREATE_JOINABLE

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_detach(pthread_t thread);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>
    
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_mutex_trylock(pthread_mutex_t *mutex);

result = pthread_mutex_trylock(&g_mutex);
    
if (result != 0)
	if (result == EBUSY) {
            <başka bir şeyler yap>
        }
        else 
            exit_sys_errno("pthread_mutex_trylock", result);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime);

struct timespec ts;

if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
	exit_sys("clock_gettime");

ts.tv_sec += 5;

result = pthread_mutex_timedlock(&g_mutex, &ts);

if (result != 0) {
	if (result == ETIMEDOUT) {
            <fonksiyon zaman aşımından dolayı sonlandı>
        }
        else 
            exit_sys_errno("pthread_timedlock, result);
}
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

Fonksiyonun birinci parametresi mutex özellik nesnesini ikinci parametresi mutex'in türünü almaktadır. Tür şunlardan biri olabilir:

PTHREAD_MUTEX_NORMAL: Mutex'in sahipliği ikinci kez alınmak istenirse kilitlenme "deadlock" oluşur.

PTHREAD_MUTEX_ERRORCHECK: Şu durumlarda fonksiyonlar başarısız olmaktadır:

- Mutex nesnesnin sahipliği ikinci kez alınmaya çalışıldığında
- Mutex nesnesinin sahipliğini almadan pthread_mutex_unlock işlemi uygulandığında

PTHREAD_MUTEX_RECURSIVE: Mutex'in sahipliğini alan thread yeniden pthread_mutex_lock fonksiyonu ile sahipliği alabilir. 
Ancak bu durumda fonksiyon sahipliğini aldığı miktarda onu pthread_mutex_unlock uygulamalıdır. Recursive mutex'ler için mutex 
nesnesinin içerisinde bir sayaç bulundurulmaktadır. (Yani her pthread_mutex_lock fonksiyonundan geçildiğinde mutex'in sayacı 1
artırılır, her pthread_mutex_unlock fonksiyonundan geçildiğinde sayaç 1 eksiltilir. Sayaç 0'a düşünce mutex'in kilidi açılır.)

PTHREAD_MUTEX_DEFAULT: Bu default durumdur. POSIX standartlarına göre bu default durum yukarıdaki üç durumdan biri olabilir. 
Linux sistemlerinde default durum PTHREAD_MUTEX_NORMAL ile aynıdır. 

Eğer mutex nesnesinin türü set edilmediyse mutex nesnesi default olarak PTHREAD_MUTEX_DEFAULT durumda olur. Yukarıda da belirtildiği gibi 
Linux sistemlerinde bu değer zaten PTHREAD_MUTEX_NORMAL ile aynıdır. Yani default durumda Linux sistemlerinde thread yeniden mutex nesnesinin 
sahipliğini almaya çalışırsa "deadlock" oluşmaktadır. 

Mutex nesnesinin türü de benzer biçimde pthread_mutexattr_gettype fonksiyonu ile alınabilmektedir:

#include <pthread.h>

int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);

Fonksiyon mutex'in tür bilgisini ikinci parametresiyle belirtilen nesneye yerleştirir. Başarı durumunda 0 değerine, başarısızlık 
durumunda errno değerine geri döner. 

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust);

Fonksiyonun birinci parametresi yine mutex özellik nesnesinin adresini almaktadır. İkinci parametre şu değerlerden biri olabilir:

PTHREAD_MUTEX_STALLED: Bu durumda mutex kilitli kalır ve başka bir thread mutex'i kilitlemeye çalışırsa "deadlock" oluşur.

PTHREAD_MUTEX_ROBUST: Bu durumda başka bir thread "abondened" mutex'i kilitlemeye çalışırsa pthread_mutex_lock başarısız olur
ve fonksiyon EOWNERDEAD errno değeri ile geri döner. Ancak POSIX standartlarına göre bu kilitlemeyi ilk yapmaya çalışan thread'de
bu hata elde edilir. Diğer thread'lerin yeniden bu mutex'i kilitlemeye çalışması durumunda yeniden EOWNERDEAD hatasının elde edilip
edilmeyeceği işletim sistemini yazanların isteğine bırakılmıştır. Sahibi sonlanmış bir mutex kilitlenmeye çalışılırken EOWNERDEAD 
errno değeri ile fonksiyon geri döndüğünde thread'in yeniden kullanılabilir hale getirilebilmesi için pthread_mutex_consistent 
fonksiyonun çağrılması gerekmektedir. Fonksiyonun prototipi şöyledir:

#include <pthread.h>

int pthread_mutex_consistent(pthread_mutex_t *mutex);

Fonksiyon parametre olarak mutex nesnesinin adresini alır. Başarı durumunda 0 değerine başarısızlık durumunda errno değerine geri döner. 
Mutex "consistent" duruma sokulduğunda aynı zamanda kilitlenmiş de olur. Örneğin:

result = pthread_mutex_lock(&g_mutex);

if (result == EOWNERDEAD) {
	if ((result = pthread_mutex_consistent(&g_mutex)) != 0)
    		exit_sys_errno("pthread_mutex_consistent", result);

	/* mutex locked durumda *
}
else 
	exit_sys_errno("pthread_mutex_lock", result);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared); 
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

pthread_mutex_lock(&g_mutex);

while (<koşul sağlanmadığı sürece>)
        pthread_cond_wait(&cond, &g_mutex);

/* kritik kod işlemleri */

pthread_mutex_unlock(&g_mutex);

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <pthread.h>

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared); 
int pthread_condattr_getpshared(const pthread_condattr_t *attr, int * pshared);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <pthread.h>

int pthread_condattr_getclock(const pthread_condattr_t *attr, clockid_t *clock_id);
int pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clock_id);
	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned value);  

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

#include <semaphore.h>

int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	
#include <semaphore.h>

int sem_destroy(sem_t *sem);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
	


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------


	
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------