/* * 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 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright (c) 2012 by Delphix. All rights reserved. */ /* * Module: zones_locks.c * Group: libinstzones * Description: Provide "zones" locking interfaces for install consolidation * code * * Public Methods: * * _z_acquire_lock - acquire a lock on an object on a zone * _z_adjust_lock_object_for_rootpath - Given a lock object and a root path, * if the root path is not * _z_lock_zone - Acquire specified locks on specified zone * _z_lock_zone_object - lock a single lock object in a specified zone * _z_release_lock - release a lock held on a zone * _z_unlock_zone - Released specified locks on specified zone * _z_unlock_zone_object - unlock a single lock object in a specified zone */ /* * System includes */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <ctype.h> #include <sys/types.h> #include <sys/param.h> #include <string.h> #include <strings.h> #include <stdarg.h> #include <limits.h> #include <errno.h> #include <time.h> #include <stropts.h> #include <libintl.h> #include <locale.h> #include <assert.h> /* * local includes */ #include "instzones_lib.h" #include "zones_strings.h" /* * Private structures */ /* * Library Function Prototypes */ /* * Local Function Prototypes */ boolean_t _z_adjust_lock_object_for_rootpath(char **r_result, char *a_lockObject); boolean_t _z_acquire_lock(char **r_lockKey, char *a_zoneName, char *a_lock, pid_t a_pid, boolean_t a_wait); boolean_t _z_lock_zone(zoneListElement_t *a_zlst, ZLOCKS_T a_lflags); boolean_t _z_lock_zone_object(char **r_objectLocks, char *a_zoneName, char *a_lockObject, pid_t a_pid, char *a_waitingMsg, char *a_busyMsg); boolean_t _z_release_lock(char *a_zoneName, char *a_lock, char *a_key, boolean_t a_wait); boolean_t _z_unlock_zone(zoneListElement_t *a_zlst, ZLOCKS_T a_lflags); boolean_t _z_unlock_zone_object(char **r_objectLocks, char *a_zoneName, char *a_lockObject, char *a_errMsg); /* * global internal (private) declarations */ /* * ***************************************************************************** * global external (public) functions * ***************************************************************************** */ /* * Name: _z_acquire_lock * Description: acquire a lock on an object on a zone * Arguments: r_lockKey - [RW, *RW] - (char *) * Pointer to handle to string representing the lock key * associated with the lock object to be acquired - this * key is returned when the lock is acquired and must be * provided when releasing the lock * == (char *)NULL - lock not acquired * a_zoneName - [RO, *RO] - (char *) * Pointer to string representing the name of the zone to * acquire the specified lock on * a_lockObject - [RO, *RO] - (char *) * Pointer to string representing the lock object to * acquire on the specified zone * a_pid - [RO, *RO] - (pid_t) * Process i.d. to associate with this lock * == 0 - no process i.d. associated with the lock * a_wait - [RO, *RO] - (int) * Determines what to do if the lock cannot be acquired: * == B_TRUE - wait for the lock to be acquired * == B_FALSE - do not wait for the lock to be acquired * Returns: boolean_t * B_TRUE - lock acquired * B_FALSE - lock not acquired */ boolean_t _z_acquire_lock(char **r_lockKey, char *a_zoneName, char *a_lockObject, pid_t a_pid, boolean_t a_wait) { argArray_t *args; boolean_t b; char *adjustedLockObject = (char *)NULL; char *p; char *results = (char *)NULL; int r; int status; /* entry assertions */ assert(a_zoneName != (char *)NULL); assert(a_lockObject != (char *)NULL); assert(*a_lockObject != '\0'); assert(r_lockKey != (char **)NULL); /* entry debugging info */ _z_echoDebug(DBG_ZONES_APLK, a_zoneName, a_lockObject, a_pid); /* reset returned lock key handle */ *r_lockKey = (char *)NULL; /* * Only one lock file must ever be used - the one located on the root * file system of the currently running Solaris instance. To allow for * alternative roots to be properly locked, adjust the lock object to * take root path into account; if necessary, the root path will be * prepended to the lock object. */ b = _z_adjust_lock_object_for_rootpath(&adjustedLockObject, a_lockObject); if (!b) { return (B_FALSE); } /* * construct command arguments: * pkgadm lock -a -q -o adjustedLockObject [ -w -W timeout ] * [ -p a_pid -z zoneid ] */ args = _z_new_args(20); /* generate new arg list */ (void) _z_add_arg(args, PKGADM_CMD); /* pkgadm command */ (void) _z_add_arg(args, "lock"); /* lock sub-command */ (void) _z_add_arg(args, "-a"); /* acquire lock */ (void) _z_add_arg(args, "-q"); /* quiet (no extra messages) */ (void) _z_add_arg(args, "-o"); /* object to acquire */ (void) _z_add_arg(args, "%s", adjustedLockObject); /* add [ -w -W timeout ] if waiting for lock */ if (a_wait == B_TRUE) { (void) _z_add_arg(args, "-w"); /* wait */ (void) _z_add_arg(args, "-W"); /* wait timeout */ (void) _z_add_arg(args, "%ld", (long)MAX_RETRIES*RETRY_DELAY_SECS); } /* add process/zone i.d.s if process i.d. provided */ if (a_pid > 0) { (void) _z_add_arg(args, "-p"); /* lock valid process i.d. */ (void) _z_add_arg(args, "%lld", (long long)getpid()); (void) _z_add_arg(args, "-z"); /* lock valid zone i.d. */ (void) _z_add_arg(args, "%lld", (long long)getzoneid()); } /* execute command */ r = _z_zone_exec(&status, &results, (char *)NULL, PKGADM_CMD, _z_get_argv(args), a_zoneName, (int *)NULL); /* free generated argument list */ _z_free_args(args); /* return error if failed to acquire */ if ((r != 0) || (status != 0)) { _z_echoDebug(DBG_ZONES_APLK_EXIT, a_zoneName, adjustedLockObject, a_pid, r, status, results ? results : ""); /* free up results if returned */ if (results) { free(results); } /* free adjusted lock object */ free(adjustedLockObject); /* return failure */ return (B_FALSE); } /* return success if no results returned */ if (results == (char *)NULL) { return (B_TRUE); } /* return the lock key */ p = _z_strGetToken((char *)NULL, results, 0, "\n"); _z_strRemoveLeadingWhitespace(&p); *r_lockKey = p; /* exit debugging info */ _z_echoDebug(DBG_ZONES_APLK_RESULTS, a_zoneName, adjustedLockObject, p, results); /* free up results */ free(results); /* free adjusted lock object */ free(adjustedLockObject); /* return success */ return (B_TRUE); } /* * Name: _z_adjust_lock_object_for_rootpath * Description: Given a lock object and a root path, if the root path is not * the current running system root, then alter the lock object * to contain a reference to the root path. Only one lock file must * ever be used to create and maintain locks - the lock file that * is located in /tmp on the root file system of the currently * running Solaris instance. To allow for alternative roots to be * properly locked, if necessary adjust the lock object to take * root path into account. If the root path does not indicate the * current running Solaris instance, then the root path will be * prepended to the lock object. * Arguments: r_result - [RW, *RW] - (char **) * Pointer to handle to character string that will contain * the lock object to use. * a_lockObject - [RO, *RO] - (char *) * Pointer to string representing the lock object to adjust * Returns: boolean_t * B_TRUE - lock object adjusted and returned * B_FALSE - unable to adjust lock object * NOTE: Any string returned is placed in new storage for the * calling function. The caller must use 'free' to dispose * of the storage once the string is no longer needed. * * A lock object has this form: * * name.value [ /name.value [ /name.value ... ] ] * * The "value is either a specific object or a "*", for example: * * package.test * * This locks the package "test" * * zone.* /package.* * * This locks all packages on all zones. * * zone.* /package.SUNWluu * * This locks the package SUNWluu on all zones. * * If a -R rootpath is specified, since there is only one lock file in * the current /tmp, the lock object is modified to include the root * path: * * rootpath.rootpath/zone.* /package.* * * locks all packages on all zones in the root path "?" * * The characters "/" and "*" and "." cannot be part of the "value"; that * is if "-R /tmp/gmg*dir.test-path" is specified, the final object * cannot be: * * rootpath./tmp/gmg*dir.test-path/zone.* /package.* * * This would be parsed as: * * "rootpath." "/tmp" "gmg*dir.test-path" "zone.*" "package.*" * * which is not correct. * * So the path is modified by the loop, in this case it would result in * this lock object: * * rootpath.-1tmp-1gmg-3dir-2test---path/zone.* /package.* * * This is parsed as: * * "rootpath.-1tmp-1gmg-3dir-2test---path" "zone.*" "package.*" * * which is then interpreted as: * * "rootpath./tmp/gmg*dir.test-path" "zone.*" "package.*" */ boolean_t _z_adjust_lock_object_for_rootpath(char **r_result, char *a_lockObject) { char realRootPath[PATH_MAX] = {'\0'}; const char *a_rootPath; /* entry assertions */ assert(r_result != (char **)NULL); assert(a_lockObject != (char *)NULL); assert(*a_lockObject != '\0'); /* reset returned lock object handle */ *r_result = (char *)NULL; /* * if root path points to "/" return a duplicate of the passed in * lock objects; otherwise, resolve root path and adjust lock object by * prepending the rootpath to the lock object (using LOBJ_ROOTPATH). */ a_rootPath = _z_global_data._z_root_dir; if ((a_rootPath == (char *)NULL) || (*a_rootPath == '\0') || (strcmp(a_rootPath, "/") == 0)) { /* root path not specified or is only "/" - no -R specified */ *r_result = _z_strdup(a_lockObject); } else { /* * root path is not "" or "/" - -R to an alternative root has * been specified; resolve all symbolic links and relative nodes * of path name and determine absolute path to the root path. */ if (realpath(a_rootPath, realRootPath) == (char *)NULL) { /* cannot determine absolute path; use path specified */ (void) strlcpy(realRootPath, a_rootPath, sizeof (realRootPath)); } /* * if root path points to "/" duplicate existing lock object; * otherwise, resolve root path and adjust lock object by * prepending the rootpath to the lock object */ if (strcmp(realRootPath, "/") == 0) { *r_result = _z_strdup(a_lockObject); } else { char *p1, *p2, *p3; /* prefix out /.* which cannot be part of lock object */ p1 = _z_calloc((strlen(realRootPath)*2)+1); for (p3 = p1, p2 = realRootPath; *p2 != '\0'; p2++) { switch (*p2) { case '/': /* / becomes -1 */ *p3++ = '-'; *p3++ = '1'; break; case '.': /* . becomes -2 */ *p3++ = '-'; *p3++ = '2'; break; case '*': /* * becomes -3 */ *p3++ = '-'; *p3++ = '3'; break; case '-': /* - becomes -- */ *p3++ = '-'; *p3++ = '-'; break; default: /* do not prefix out char */ *p3++ = *p2; break; } } /* create "realpath.%s" object */ p2 = _z_strPrintf(LOBJ_ROOTPATH, p1); free(p1); if (p2 == (char *)NULL) { _z_program_error(ERR_MALLOC, "<path>", errno, strerror(errno)); return (B_FALSE); } /* create "realpath.%s/..." final lock object */ *r_result = _z_strPrintf("%s/%s", p2, a_lockObject); free(p2); if (*r_result == (char *)NULL) { _z_program_error(ERR_MALLOC, "<path>", errno, strerror(errno)); return (B_FALSE); } } } /* exit debugging info */ _z_echoDebug(DBG_ZONES_ADJLCKOBJ_EXIT, a_lockObject, *r_result, a_rootPath ? a_rootPath : "", realRootPath ? realRootPath : ""); /* return success */ return (B_TRUE); } /* * Name: _z_lock_zone * Description: Acquire specified locks on specified zone * Arguments: a_zlst - [RO, *RW] - (zoneListElement_t *) * Pointer to zone list structure element describing * the zone the lock - the structure is updated with * the lock objects and keys if the locks are acquired * a_lflags - [RO, *RO] - (ZLOCKS_T) * Flags indicating which locks to acquire on the zone * Returns: boolean_t * == B_TRUE - locks successfully acquired * == B_FALSE - failed to acquire the locks */ boolean_t _z_lock_zone(zoneListElement_t *a_zlst, ZLOCKS_T a_lflags) { char *scratchName; boolean_t b; /* entry assertions */ assert(a_zlst != (zoneListElement_t *)NULL); /* entry debugging info */ _z_echoDebug(DBG_ZONES_LCK_ZONE, a_zlst->_zlName, a_lflags); scratchName = a_zlst->_zlScratchName == NULL ? a_zlst->_zlName : a_zlst->_zlScratchName; /* * acquire zone lock */ if (a_lflags & ZLOCKS_ZONE_ADMIN) { /* * lock zone administration if not already locked * if the lock cannot be released, stop and return an error */ _z_echoDebug(DBG_ZONES_LCK_ZONE_ZONEADM, a_zlst->_zlName, LOBJ_ZONEADMIN); b = _z_lock_zone_object(&a_zlst->_zlLockObjects, scratchName, LOBJ_ZONEADMIN, (pid_t)0, MSG_ZONES_LCK_ZONE_ZONEADM, ERR_ZONES_LCK_ZONE_ZONEADM); if (b == B_FALSE) { return (b); } } /* * acquire package lock */ if (a_lflags & ZLOCKS_PKG_ADMIN) { /* * zone administration is locked; lock package administration if * not already locked; if the lock cannot be released, stop, * release the zone administration lock and return an error */ _z_echoDebug(DBG_ZONES_LCK_ZONE_PKGADM, a_zlst->_zlName, LOBJ_PKGADMIN); b = _z_lock_zone_object(&a_zlst->_zlLockObjects, scratchName, LOBJ_PKGADMIN, (pid_t)0, MSG_ZONES_LCK_ZONE_PKGADM, ERR_ZONES_LCK_ZONE_PKGADM); if (b == B_FALSE) { (void) _z_unlock_zone(a_zlst, a_lflags); return (b); } } /* * all locks have been obtained - return success! */ return (B_TRUE); } /* * Name: _z_lock_zone_object * Description: lock a single lock object in a specified zone * Arguments: r_objectLocks - [RW, *RW] - (char **) * Pointer to handle to character string containing a list * of all objects locked for this zone - this string will * have the key to release the specified object added to it * if the lock is acquired. * a_zoneName - [RO, *RO] - (char *) * Pointer to string representing the name of the zone to * acquire the specified lock on * a_lockObject - [RO, *RO] - (char *) * Pointer to string representing the lock object to * acquire on the specified zone * a_pid - [RO, *RO] - (pid_t) * Process i.d. to associate with this lock * == 0 - no process i.d. associated with the lock * a_waitingMsg - [RO, *RO] - (char *) * Localized message to be output if waiting for the lock * because the lock cannot be immediately be acquired * a_busyMsg - [RO, *RO] - (char *) * Localized message to be output if the lock cannot be * released * Returns: boolean_t * B_TRUE - lock released * B_FALSE - lock not released */ boolean_t _z_lock_zone_object(char **r_objectLocks, char *a_zoneName, char *a_lockObject, pid_t a_pid, char *a_waitingMsg, char *a_busyMsg) { boolean_t b; char *p = (char *)NULL; char lockItem[LOCK_OBJECT_MAXLEN+LOCK_KEY_MAXLEN+4]; char lockKey[LOCK_KEY_MAXLEN+2]; char lockObject[LOCK_OBJECT_MAXLEN+2]; int i; /* entry assertions */ assert(r_objectLocks != (char **)NULL); assert(a_zoneName != (char *)NULL); assert(a_waitingMsg != (char *)NULL); assert(a_busyMsg != (char *)NULL); assert(a_lockObject != (char *)NULL); assert(*a_lockObject != '\0'); /* entry debugging info */ _z_echoDebug(DBG_ZONES_LCK_OBJ, a_lockObject, a_zoneName, a_pid, *r_objectLocks ? *r_objectLocks : ""); /* if lock objects held search for object to lock */ if (*r_objectLocks != (char *)NULL) { for (i = 0; ; i++) { /* get next object locked on this zone */ _z_strGetToken_r((char *)NULL, *r_objectLocks, i, "\n", lockItem, sizeof (lockItem)); /* break out of loop if no more locks in list */ if (lockItem[0] == '\0') { _z_echoDebug(DBG_ZONES_LCK_OBJ_NOTHELD, a_lockObject, a_zoneName); break; } /* get object and key for this lock */ _z_strGetToken_r((char *)NULL, lockItem, 0, "\t", lockObject, sizeof (lockObject)); _z_strGetToken_r((char *)NULL, lockItem, 1, "\t", lockKey, sizeof (lockKey)); /* return success if the lock is held */ if (strcmp(lockObject, a_lockObject) == 0) { _z_echoDebug(DBG_ZONES_LCK_OBJ_FOUND, lockObject, lockKey); return (B_TRUE); } /* not the object to lock - scan next object */ _z_echoDebug(DBG_ZONES_LCK_OBJ_NOTFOUND, lockObject, lockKey); } } /* * the object to lock is not held - acquire the lock */ /* acquire object with no wait */ b = _z_acquire_lock(&p, a_zoneName, a_lockObject, a_pid, B_FALSE); if (b == B_FALSE) { /* failure - output message and acquire with wait */ _z_echo(a_waitingMsg, (long)MAX_RETRIES*RETRY_DELAY_SECS, a_zoneName, _z_global_data._z_root_dir); b = _z_acquire_lock(&p, a_zoneName, a_lockObject, a_pid, B_TRUE); } /* output error message and return failure if both acquires failed */ if (b == B_FALSE) { _z_program_error(a_busyMsg, a_zoneName); return (b); } /* add object/key to held locks */ _z_strPrintf_r(lockItem, sizeof (lockItem), "%s\t%s", a_lockObject, p); _z_strAddToken(r_objectLocks, lockItem, '\n'); free(p); /* return success */ return (B_TRUE); } /* * Name: _z_release_lock * Description: release a lock held on a zone * Arguments: a_zoneName - [RO, *RO] - (char *) * Pointer to string representing the name of the zone to * release the specified lock on * a_lockObject - [RO, *RO] - (char *) * Pointer to string representing the lock object to * release on the specified zone * a_lockKey - [RO, *RO] - (char *) * Pointer to string representing the lock key associated * with the lock object to be released - this key is * returned when the lock is acquired and must be provided * when releasing the lock * a_wait - [RO, *RO] - (int) * Determines what to do if the lock cannot be released: * == B_TRUE - wait for the lock to be released * == B_FALSE - do not wait for the lock to be released * Returns: boolean_t * B_TRUE - lock released * B_FALSE - lock not released */ boolean_t _z_release_lock(char *a_zoneName, char *a_lockObject, char *a_lockKey, boolean_t a_wait) { argArray_t *args; boolean_t b; char *adjustedLockObject = (char *)NULL; char *results = (char *)NULL; int r; int status; /* entry assertions */ assert(a_zoneName != (char *)NULL); assert(a_lockObject != (char *)NULL); assert(*a_lockObject != '\0'); assert(a_lockKey != (char *)NULL); assert(*a_lockKey != '\0'); /* entry debugging info */ _z_echoDebug(DBG_ZONES_RELK, a_zoneName, a_lockObject, a_lockKey ? a_lockKey : ""); /* * Only one lock file must ever be used - the one located on the root * file system of the currently running Solaris instance. To allow for * alternative roots to be properly locked, adjust the lock object to * take root path into account; if necessary, the root path will be * prepended to the lock object. */ b = _z_adjust_lock_object_for_rootpath(&adjustedLockObject, a_lockObject); if (!b) { return (B_FALSE); } /* * construct command arguments: * pkgadm lock -r -o adjustedLockObject -k a_lockKey [-w -W timeout] */ args = _z_new_args(20); /* generate new arg list */ (void) _z_add_arg(args, PKGADM_CMD); /* pkgadm command */ (void) _z_add_arg(args, "lock"); /* lock sub-command */ (void) _z_add_arg(args, "-r"); /* release lock */ (void) _z_add_arg(args, "-o"); /* object to release */ (void) _z_add_arg(args, "%s", adjustedLockObject); (void) _z_add_arg(args, "-k"); /* object's key */ (void) _z_add_arg(args, "%s", a_lockKey); /* add [ -w -W timeout ] if waiting for lock */ if (a_wait == B_TRUE) { (void) _z_add_arg(args, "-w"); /* wait */ (void) _z_add_arg(args, "-W"); /* wait timeout */ (void) _z_add_arg(args, "%ld", (long)MAX_RETRIES*RETRY_DELAY_SECS); } /* execute command */ r = _z_zone_exec(&status, &results, (char *)NULL, PKGADM_CMD, _z_get_argv(args), a_zoneName, (int *)NULL); /* free generated argument list */ _z_free_args(args); /* exit debugging info */ _z_echoDebug(DBG_ZONES_RELK_EXIT, adjustedLockObject, a_lockKey, a_zoneName, r, status, results ? results : ""); /* free adjusted lock object */ free(adjustedLockObject); free(results); return (((r == 0) && (status == 0)) ? B_TRUE : B_FALSE); } /* * Name: _z_unlock_zone * Description: Released specified locks on specified zone * Arguments: a_zlst - [RO, *RW] - (zoneListElement_t *) * Pointer to zone list structure element describing * the zone the unlock - the structure is updated by * removing the lock object and key if the locks are * successfully released * a_lflags - [RO, *RO] - (ZLOCKS_T) * Flags indicating which locks to release on the zone * Returns: boolean_t * == B_TRUE - locks successfully released * == B_FALSE - failed to release the locks */ boolean_t _z_unlock_zone(zoneListElement_t *a_zlst, ZLOCKS_T a_lflags) { char *scratchName; boolean_t b; boolean_t errors = B_FALSE; /* entry assertions */ assert(a_zlst != (zoneListElement_t *)NULL); /* entry debugging info */ _z_echoDebug(DBG_ZONES_ULK_ZONE, a_zlst->_zlName, a_lflags); scratchName = a_zlst->_zlScratchName == NULL ? a_zlst->_zlName : a_zlst->_zlScratchName; if (a_lflags & ZLOCKS_PKG_ADMIN) { /* * if locked, unlock package administration lock * if the lock cannot be released, continue anyway */ _z_echoDebug(DBG_ZONES_ULK_ZONE_PKGADM, a_zlst->_zlName, LOBJ_PKGADMIN); b = _z_unlock_zone_object(&a_zlst->_zlLockObjects, scratchName, LOBJ_PKGADMIN, WRN_ZONES_ULK_ZONE_PKGADM); if (b == B_FALSE) { errors = B_TRUE; } } if (a_lflags & ZLOCKS_ZONE_ADMIN) { /* * if locked, unlock zone administration lock * if the lock cannot be released, continue anyway */ _z_echoDebug(DBG_ZONES_ULK_ZONE_ZONEADM, a_zlst->_zlName, LOBJ_ZONEADMIN); b = _z_unlock_zone_object(&a_zlst->_zlLockObjects, scratchName, LOBJ_ZONEADMIN, WRN_ZONES_ULK_ZONE_ZONEADM); if (b == B_FALSE) { errors = B_TRUE; } } return (!errors); } /* * Name: _z_unlock_zone_object * Description: unlock a single lock object in a specified zone * Arguments: r_objectLocks - [RW, *RW] - (char **) * Pointer to handle to character string containing a list * of all objects locked for this zone - this string must * contain the key to release the specified object - if not * then the lock is not released - if so then the lock is * released and the key is removed from this list. * a_zoneName - [RO, *RO] - (char *) * Pointer to string representing the name of the zone to * release the specified lock on * a_lockObject - [RO, *RO] - (char *) * Pointer to string representing the lock object to * release on the specified zone * a_errMsg - [RO, *RO] - (char *) * Localized message to be output if the lock cannot be * released * Returns: boolean_t * B_TRUE - lock released * B_FALSE - lock not released */ boolean_t _z_unlock_zone_object(char **r_objectLocks, char *a_zoneName, char *a_lockObject, char *a_errMsg) { boolean_t b; char lockItem[LOCK_OBJECT_MAXLEN+LOCK_KEY_MAXLEN+4]; char lockKey[LOCK_KEY_MAXLEN+2]; char lockObject[LOCK_OBJECT_MAXLEN+2]; int i; /* entry assertions */ assert(r_objectLocks != (char **)NULL); assert(a_zoneName != (char *)NULL); assert(a_errMsg != (char *)NULL); assert(a_lockObject != (char *)NULL); assert(*a_lockObject != '\0'); /* entry debugging info */ _z_echoDebug(DBG_ZONES_ULK_OBJ, a_lockObject, a_zoneName, *r_objectLocks ? *r_objectLocks : ""); /* return success if no objects are locked */ if (*r_objectLocks == (char *)NULL) { _z_echoDebug(DBG_ZONES_ULK_OBJ_NONE, a_zoneName); return (B_TRUE); } /* see if the specified lock is held on this zone */ for (i = 0; ; i++) { /* get next object locked on this zone */ _z_strGetToken_r((char *)NULL, *r_objectLocks, i, "\n", lockItem, sizeof (lockItem)); /* return success if no more objects locked */ if (lockItem[0] == '\0') { _z_echoDebug(DBG_ZONES_ULK_OBJ_NOTHELD, a_lockObject, a_zoneName); return (B_TRUE); } /* get object and key for this lock */ _z_strGetToken_r((char *)NULL, lockItem, 0, "\t", lockObject, sizeof (lockObject)); _z_strGetToken_r((char *)NULL, lockItem, 1, "\t", lockKey, sizeof (lockKey)); /* break out of loop if object is the one to unlock */ if (strcmp(lockObject, a_lockObject) == 0) { _z_echoDebug(DBG_ZONES_ULK_OBJ_FOUND, lockObject, lockKey); break; } /* not the object to unlock - scan next object */ _z_echoDebug(DBG_ZONES_ULK_OBJ_NOTFOUND, lockObject, lockKey); } /* * the object to unlock is held - release the lock */ /* release object with wait */ b = _z_release_lock(a_zoneName, a_lockObject, lockKey, B_TRUE); if (b == B_FALSE) { /* failure - issue error message and return failure */ _z_program_error(a_errMsg, a_zoneName); return (b); } /* remove object/key from held locks */ _z_strRemoveToken(r_objectLocks, lockItem, "\n", 0); /* return success */ return (B_TRUE); }
