Atomic File Operations Using File Lock - POSIX

If a file is shared between several tasks in an application, the file lock can be employed to guarantee that a series of file operations are executed atomically. fs_flockfile() (or its non-blocking equivalent fs_ftrylockfile()) acquires the lock for a task (if it does not already own it). Accesses from other tasks will be blocked until fs_funlockfile() is called.

Each file actually has a lock count associated with it. This allows nested calls by a task to acquire a file lock; each of those calls must be matched with a call to fs_funlockfile(). Listing - Example file lock usage shows how the file lock functions can be used.

Listing - Example file lock usage

void  App_Fnct (void)
{
    unsigned  char  data1[50];
    unsigned  char  data2[10];
    .
    .
    .
   
    if (App_FilePtr != (FS_FILE *)0) {             (1)
        fs_flockfile(App_FilePtr);                 /* Lock file.                           */
                                                   
                                                   /* Wr data atomically.                  */
        fs_fwrite(data1, 1, sizeof(data1), App_FilePtr);
        fs_fwrite(data2, 1, sizeof(data1), App_FilePtr);
        fs_funlockfile(App_FilePtr);               /* Unlock file.                         */
    } 
    .
    .
    .
}

(1) fs_flockfile() will block the calling task until the file is available. If the task must write to the file only if no other task is currently accessing it, the non-blocking function fs_funlockfile() can be used.