paraslash/ipc.h, branch pu

Merge topic branch t/spdx into master

2026-03-26T15:50:54Z

Switch to SPDX licence identifiers A single patch which replaces the first comment line of most .c and .h files containing the copyright notice by standardized SPDX (Software/System Package Data Exchange) nomenclature. * t/spdx: Switch to SPDX identifiers.

ipc.c: Drop return value of mutex_destroy().

2026-03-18T21:37:46Z

No caller checks the return value. Log a message on errors rather than fail silently.

Switch to SPDX identifiers.

2026-03-17T22:45:43Z

Generated with sed -i 's|Copyright.*Andre Noll.*|SPDX-License-Identifier: GPL-2.0 */|g' *.c *.h followed by manually tweaking the result a bit. No license change intended.

load_chunk_table(): Don't trust afhi->chunks_total.

2017-03-25T10:54:36Z

Both callers pass a buffer to load_chunk_table() to initialize afhi->chunk_table. The function does not check the size of the passed buffer but relies on afhi->chunks_total to tell how many values to copy from the buffer. In other words, the buffer size gives an upper bound for the number of chunks in the chunk table, but this bould is not checked. This patch makes the code more robust by adding a suitable check. To this aim, load_chunk_table() is changed to receive a pointer to an osl object (which contains the buffer size) rather than only the buffer. One caller, load_afd(), initializes the chunk table from a shared memory area buffer. It does not know or care about the buffer size so far. We introduce the the new IPC helper shm_size() to let it tell the size of the area and pass it to load_chunk_table().

ipc: Determine maximal size of a shared memory area at runtime.

2011-09-16T19:41:47Z

During command dispatch, the afs process allocates shm areas for the query result and passes the identifiers via the local socket to the child process of para_server which is executing the command. If the write to the (non-blocking) local socket fails, for example because the call would block, afs closes the connection to the child process immediately to avoid deadlocks. Therefore the maximal output size of an (afs) command depends linearly on the size of the shared memory areas, so it is desirable to allocate areas as large as possible. Currently, we use the SHMMAX if it is defined and fall back to the safe default value of 64K otherwise. However, this default is much smaller than the typical limit of 32M on Linux. Moreover, the maximal size of a shared memory area (shmmax) can be set at any time on most if not all operating systems, so runtime detection of shmmax is to be preferred. Unfortunately the way to obtain shmmax varies between operating systems. On Linux, the value is available as the contents of a file in /proc while on {Free,Net}BSD and Darwin sysctlbyname() must be called. Moreover, BSD and Darwin use different identifiers for the sysctlbyname() call. So any code that determines shmmax at runtime and works on all of the above systems must necessarily be ugly. This patch tries to concentrate all ugliness in the new shm_get_shmmax() function, so that the changes outside of ipc.c consist only of replacements SHMMAX -> shm_get_shmmax() and of the removal of the default SHMMAX setting. The new function only determines shmmax once when it is called for the first time.

Complete the afs callback conversion.

2008-03-24T23:18:01Z

This makes it possible for the callbacks to pass a partial result buffer through the command handler <-> callback socket. This removes a serious limitation of previous paraslash-0.3.x versions: As callbacks could not send data directly to the command handler they had to store the full command output in a buffer. This buffer was sent to the command handler after the callback returns. The problem with this approach is that it caused the callbacks to allocate large amounts of memory. If that amount exceeded what can be stored in a shared memory area (32MB on Linux), the command even failed. The fix consists of adding a max_size field and a max_size_handler function pointer to the para_buffer structure. Whenever para_printf() would need to allocate more memory than specified by max_size, it calls the max_size_handler which is supposed to send out the data. para_printf then prints the requested data into the old but now empty buffer. Almost all users set the max_size_handler to pass_buffer_as_shm(), a helper function implemented in afs.c that copies the buffer to a shared memory area and sends its identifier through the socket.

add more missing documentation

2007-02-10T18:54:26Z

fix the plm database tool

2006-02-21T14:52:45Z

(Re)loading the playlist uses the new mutex and shm helpers and is hopefully a race-free implementation. It works as follows: The plm init function (parent, server context) reserves a shared memory area (client data) as well as two unlocked mutexes. The first mutex serializes access for racing clients that want to replace the playlist. The second mutex serializes the access between parent and child (com_lpl()). com_lpl() loads the playlist from the client into a tmp buffer. It then creates a shm area (client_shm) and copies that buffer to the area. Further, another mutex (shm) is created. This mutex is initially locked. Next, it grabs the client lock and the server lock, and updates client_data with the id of client_shm. Then the parent is woken up (SIGUSR1) and the server lock is released. com_lpl() finally goes to sleep by acquiring the shm lock. In this situation, only the parent may run. It grabs the server lock, reads client_data to attach client_shm and reloads the playlist with data from client_shm. When ready, the parent detaches client_shm, and drops the shm lock and the server lock. This wakes up com_lpl() which destroys client_shm, the shm mutex and the tmp buffer.

The new ipc subsystem

2006-02-21T07:12:46Z

Contains functions for dealing with mutexes and shared memory.