Study on deadlocks in Linux operating systems

Study on deadlocks in Linux operating systems-general Linux technology-Linux programming and kernel information. The following is a detailed description. Related functions:
Fcntl (), signal series (this is not the focus of the discussion)
Related Data Structure
Struct flock
{
...
Short l_type;/* Type of lock: F_RDLCK,
F_WRLCK, F_UNLCK */
Short l_whence;/* How to interpret l_start:
SEEK_SET, SEEK_CUR, SEEK_END */
Off_t l_start;/* Starting offset for lock */
Off_t l_len;/* Number of bytes to lock */
Pid_t l_pid;/* PID of process blocking our lock
(F_GETLK only )*/
...
};

Code:
# Include
# Include
# Include
# Include
# Include
# Include

# Define FORPAR 0
# Define FORCHD 1
# Define PARSNT SIGUSR1
# Define CHDSNT SIGUSR2

# Define TESTFILE "/dev/shm/test"

Int
Main ()
{
Void wake (); // wake up function
Struct flock lock;
Int fd;
Sigset_t set;
Pid_t pid;

// --------- Create a file
If (fd = open (TESTFILE, O_WRONLY | O_CREAT | O_TRUNC, 0600) =-1)
{
Perror ("open () fail ");
Exit (1 );
}

Write (fd, "abcd", 2 );

// ------- Setting the lock
Lock. l_whence = SEEK_SET;
Lock. l_len = 1;
Lock. l_type = F_WRLCK;

// ------- Setting the signal set
Sigfillset (& set );
Sigdelset (& set, SIGINT );
If (sigprocmask (SIG_SETMASK, & set, NULL) =-1)
{
Perror ("setting mask fail ");
Exit (1 );
}

If (pid = fork () = 0)
{
Lock. l_start = FORCHD;
If (fcntl (fd, F_SETLKW, & lock) =-1)
{
Perror ("setting lock fail ...");
Exit (1 );
}
Else
// Puts ("Child: I have lock my own part! ");

Signal (PARSNT, wake); // handle parent's signal
Kill (getppid (), CHDSNT); // telling parent that his has done his job
Sigdelset (& set, PARSNT );
Sigsuspend (& set); // waiting for parent's information;

Lock. l_start = FORPAR; // to lock the parent's part
If (fcntl (fd, F_SETLKW, & lock) =-1)
{
Perror ("child: setting lock fail ...");
# Ifndef DEBUG
Exit (1 );
# Endif
}
Else
Puts ("Suceed to lock parent's part ...");

_ Exit (0 );
}


// Parent ----------------------------
Lock. l_start = FORPAR;
If (fcntl (fd, F_SETLKW, & lock) =-1)
{
Perror ("setting lock fail ...");
Exit (1 );
}
Else
// Puts ("Parent: I have lock my own part! ");

Signal (CHDSNT, wake); // handle child's signal
Kill (pid, PARSNT); // telling child that his has done his job
Sigdelset (& set, CHDSNT );
Sigsuspend (& set); // waiting for child's information;

Lock. l_start = FORCHD;
If (fcntl (fd, F_SETLKW, & lock) =-1)
{
Perror ("parent: setting lock fail ...");
# Ifndef DEBUG
Exit (1 );
# Endif
}
Else
Puts ("Suceed to lock child's part ...");

Return 0;
}

Void
Wake ()
{
Return;
}

Running result:
[Sody @ longtem exercise] $./a. out
Child: setting lock fail...: Resource deadlock avoided
Suceed to lock child's part...
[Sody @ longtem exercise] $./a. out
Child: setting lock fail...: Resource deadlock avoided
Suceed to lock child's part...
[Sody @ longtem exercise] $./a. out
Child: setting lock fail...: Resource deadlock avoided
Suceed to lock child's part...
[Sody @ longtem exercise] $./a. out
Child: setting lock fail...: Resource deadlock avoided
Suceed to lock child's part...

The test results are a bit strange. Because I once ran 1000 or more times, half of the Parent and Child processes had the chance to get the lock. However, after running the same number of times, the parent process always gets it. This is not the same as in advanced programming environment.