Roland Mainz wrote:
> Jennifer Pioch wrote:
> > Any advice on a good way to implement a multiple readers/single writer
> > lock in a ksh shell script? Multiple scripts should read from a file
> > but only a single one should be allowed to update or replace the file.
> [snip]
>
> Attached (as "filemutexdemo1.ksh.txt" ; note that this demo needs
> ksh93t- from the ksh93-integration update1 tree) is a demo which shows
> an implementation of a filesystem-based mutex mechanism for shell
> scripts (based on the idea thatt directory creation and destroytion are
> "atomic" operations and that a directory cannot be removed by "rmdir"
> when it contains any files/directories (which is used to implememet the
> shared lock stuff)).
>
> The code supports:
> - "exclusive" locks
> - "shared" locks (for multiple reader/single-writer setups)
> - seperate methods to "try" to obtain a lock (without waiting).
> - Critical sections via "syncronized" and "syncronized_shared"
>
> Comments/suggestions/etc. welcome...
[snip]
And since it was Sunday, 3:34h AM I missed a bug in the code which
increases the wait time for each lock attempt a bit (to avoid that
something like a NFS server gets spammed to death by too many spinning
locks). Attached is a fixed version...
----
Bye,
Roland
P.S.: Does poll(2) work on directories (e.g. to track changes
(new/removed files/directories) or whether the directory gets removed) ?
--
__ . . __
(o.\ \/ /.o) [EMAIL PROTECTED]
\__\/\/__/ MPEG specialist, C&&JAVA&&Sun&&Unix programmer
/O /==\ O\ TEL +49 641 7950090
(;O/ \/ \O;)
#!/usr/bin/ksh93
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2008 Sun Microsystems, Inc. All rights reserved.
# Use is subject to license terms.
#
# ident "%Z%%M% %I% %E% SMI"
#
#
# filemutexdemo1 - a simple locking demo which supports read/write
# locks and critical sections (like JAVA's "syncronized" keyword)
#
# Solaris needs /usr/xpg4/bin/ because the tools in /usr/bin are not
POSIX-conformant
export PATH=/usr/xpg4/bin:/bin:/usr/bin
# Make sure all math stuff runs in the "C" locale to avoid problems
# with alternative # radix point representations (e.g. ',' instead of
# '.' in de_DE.*-locales). This needs to be set _before_ any
# floating-point constants are defined in this script).
if [[ "${LC_ALL}" != "" ]] ; then
export \
LC_MONETARY="${LC_ALL}" \
LC_MESSAGES="${LC_ALL}" \
LC_COLLATE="${LC_ALL}" \
LC_CTYPE="${LC_ALL}"
unset LC_ALL
fi
export LC_NUMERIC=C
# Definition for a mutex which uses the filesystem for locking
typeset -T filemutex_t=(
typeset name
typeset lock_dirname
typeset locked_exclusive="false"
typeset locked_shared="false"
# keep track of subshell level. The problem is that we do not know a
# way to figure out whether someone calls "unlock" in a subshell and
then
# leaves the subshell and calls "unlock" again
integer subshell=-1
typeset lock_dirname
# create a filemutex instance (including lock directory)
function create
{
# make sure we return an error if the init didn't work
set -o errexit
[[ "$1" == "" ]] && return 1
_.name="$1"
_.lock_dirname="/tmp/filemutex_t_${_.name}.lock"
mkdir "${_.lock_dirname}"
# last entry, used to mark the mutex as initalised+valid
(( _.subshell=.sh.subshell ))
return 0
}
# use a filemutex instance (same as "create" but without creating
# the lock directory)
function create_child
{
# make sure we return an error if the init didn't work
set -o errexit
[[ "$1" == "" ]] && return 1
_.name="$1"
_.lock_dirname="/tmp/filemutex_t_${_.name}.lock"
# last entry, used to mark the mutex as initalised+valid
(( _.subshell=.sh.subshell ))
return 0
}
function check_subshell
{
(( _.subshell == .sh.subshell )) && return 0
print -u2 -f "filemutex_t.%s(%s): Wrong subshell level\n" "$1"
"${_.name}"
return 1
}
function try_lock_shared
{
_.check_subshell "try_lock_shared" || return 1
mkdir "${_.lock_dirname}/shared_${PPID}_$$" 2>/dev/null ||
return 1
_.locked_shared="true"
return 0
}
function lock_shared
{
float interval=0.2
_.check_subshell "lock_shared" || return 1
while ! _.try_lock_shared ; do sleep ${interval} ; ((
interval+=interval/10. )) ; done
return 0
}
function try_lock_exclusive
{
_.check_subshell "try_lock_exclusive" || return 1
rmdir "${_.lock_dirname}" 2>/dev/null || return 1
_.locked_exclusive="true"
return 0
}
function lock_exclusive
{
float interval=0.2
_.check_subshell "lock_exclusive" || return 1
while ! _.try_lock_exclusive ; do sleep ${interval} ; ((
interval+=interval/10. )) ; done
return 0
}
# critical section support (like java's "synchronized" keyword)
function synchronized
{
integer retcode
_.check_subshell "synchronized" || return 1
_.lock_exclusive
"$@"
(( retcode=$? ))
_.unlock
return ${retcode}
}
# critical section support with shared lock
function synchronized_shared
{
integer retcode
_.check_subshell "synchronized_shared" || return 1
_.lock_shared
"$@"
(( retcode=$? ))
_.unlock
return ${retcode}
}
function unlock
{
# return an error if rmdir/mkdir/check_subshell fail...
set -o errexit
_.check_subshell "unlock"
if ${_.locked_shared} ; then
rmdir "${_.lock_dirname}/shared_${PPID}_$$"
_.locked_shared="false"
return 0
elif ${_.locked_exclusive} ; then
mkdir "${_.lock_dirname}"
_.locked_exclusive="false"
return 0
fi
print -u2 -f "filemutex_t.unlock(%s): mutex '%s' not locked."
"$1" "${_.name}"
return 1
}
# destroy mutex if noone is using it anymore (not the same as "unset"
!!))
function destroy
{
_.check_subshell "destroy" || return 1
(${_.locked_exclusive} || ${_.locked_shared}) && _.unlock
rmdir "${_.lock_dirname}"
return 0
}
)
# main
builtin mkdir
builtin rmdir
print "## Start."
typeset -r mymutexname="hello_world"
filemutex_t fs
fs.create "${mymutexname}" || print -u2 "Mutex init failed."
print "# Starting child which keeps an exclusive lock for 10 seconds..."
(
filemutex_t child_fs
child_fs.create_child "${mymutexname}"
child_fs.lock_exclusive
sleep 10
child_fs.unlock
) &
sleep 1
printf "%T: # Waiting to obtain a shared lock...\n"
fs.lock_shared
printf "%T: # Obtained shared lock\n"
printf "fs.locked_exclusive=%s, fs.locked_shared=%s\n" "${fs.locked_exclusive}"
"${fs.locked_shared}"
ls -lad /tmp/filemutex*/*
printf "%T: # Executing child which runs printf '|%%s|\\\n' 'hello' 'world'
inside a synchronized section\n"
(
filemutex_t child_fs
child_fs.create_child "${mymutexname}"
child_fs.synchronized printf '|%s|\n' 'hello' 'world'
) &
printf "%T: # Sleeping 5 secs while holding the shared lock...\n"
sleep 5.
printf "%T: # Releasing shared lock...\n"
fs.unlock
sleep 5.
print "# Destroying lock..."
fs.destroy
print "## Done."
exit 0
_______________________________________________
opensolaris-code mailing list
[email protected]
http://mail.opensolaris.org/mailman/listinfo/opensolaris-code
