static cc_int32 ccs_lock_status_add_pending_lock (ccs_lock_state_t io_lock_state,
ccs_pipe_t in_client_pipe,
ccs_pipe_t in_reply_pipe,
cc_uint32 in_lock_type,
cc_uint64 *out_lock_index)
{
cc_int32 err = ccNoError;
ccs_lock_t lock = NULL;
if (!io_lock_state ) { err = cci_check_error (ccErrBadParam); }
if (!ccs_pipe_valid (in_client_pipe)) { err = cci_check_error (ccErrBadParam); }
if (!ccs_pipe_valid (in_reply_pipe) ) { err = cci_check_error (ccErrBadParam); }
if (!err) {
err = ccs_lock_new (&lock, in_lock_type,
io_lock_state->invalid_object_err,
in_client_pipe, in_reply_pipe,
io_lock_state);
}
if (!err) {
err = ccs_lock_array_insert (io_lock_state->locks, lock,
ccs_lock_array_count (io_lock_state->locks));
if (!err) { lock = NULL; /* take ownership */ }
}
if (!err) {
*out_lock_index = ccs_lock_array_count (io_lock_state->locks) - 1;
}
ccs_lock_release (lock);
return cci_check_error (err);
}
cc_int32 ccs_lock_state_invalidate_lock (ccs_lock_state_t io_lock_state,
ccs_lock_t in_lock)
{
cc_int32 err = ccNoError;
if (!io_lock_state) {
err = ccErrBadParam;
}
if (!err) {
cc_uint64 i;
cc_uint64 count = ccs_lock_array_count (io_lock_state->locks);
for (i = 0; !err && i < count; i++) {
ccs_lock_t lock = ccs_lock_array_object_at_index (io_lock_state->locks, i);
if (lock == in_lock) {
err = ccs_lock_status_remove_lock (io_lock_state, i);
if (!err) {
err = ccs_lock_status_try_to_grant_pending_locks (io_lock_state);
break;
}
}
}
}
return cci_check_error (err);
}
static cc_int32 ccs_lock_status_try_to_grant_pending_locks (ccs_lock_state_t io_lock_state)
{
cc_int32 err = ccNoError;
cc_uint32 done = 0;
if (!io_lock_state) {
err = cci_check_error (ccErrBadParam);
}
/* Look at the pending locks and see if we can grant them.
* Note that downgrade locks mean we must check all pending locks each pass
* since a downgrade lock might be last in the list. */
while (!err && !done) {
cc_uint64 i;
cc_uint64 count = ccs_lock_array_count (io_lock_state->locks);
cc_uint32 granted_lock = 0;
for (i = io_lock_state->first_pending_lock_index; !err && i < count; i++) {
ccs_lock_t lock = ccs_lock_array_object_at_index (io_lock_state->locks, i);
cc_uint32 lock_type = 0;
ccs_pipe_t client_pipe = CCS_PIPE_NULL;
cc_uint32 can_grant_lock_now = 0;
err = ccs_lock_client_pipe (lock, &client_pipe);
if (!err) {
err = ccs_lock_type (lock, &lock_type);
}
if (!err) {
err = ccs_lock_state_check_pending_lock (io_lock_state, client_pipe,
lock_type, &can_grant_lock_now);
}
if (!err && can_grant_lock_now) {
err = ccs_lock_status_grant_lock (io_lock_state, i);
if (!err) {
granted_lock = 1;
}
}
}
if (!err && !granted_lock) {
/* we walked over all the locks and couldn't grant any of them */
done = 1;
}
}
return cci_check_error (err);
}
cc_int32 ccs_lock_state_add (ccs_lock_state_t io_lock_state,
ccs_pipe_t in_client_pipe,
ccs_pipe_t in_reply_pipe,
cc_uint32 in_lock_type,
cc_uint32 in_block,
cc_uint32 *out_will_send_reply)
{
cc_int32 err = ccNoError;
cc_uint32 can_grant_lock_now = 0;
if (!io_lock_state ) {
err = cci_check_error (ccErrBadParam);
}
if (!ccs_pipe_valid (in_client_pipe)) {
err = cci_check_error (ccErrBadParam);
}
if (!ccs_pipe_valid (in_reply_pipe) ) {
err = cci_check_error (ccErrBadParam);
}
if (!out_will_send_reply ) {
err = cci_check_error (ccErrBadParam);
}
if (!err) {
/* Sanity check: if there are any pending locks for this client
* the client must have timed out waiting for our reply. Remove any
* existing pending locks for the client. */
cc_uint64 i;
for (i = io_lock_state->first_pending_lock_index; !err && i < ccs_lock_array_count (io_lock_state->locks); i++) {
ccs_lock_t lock = ccs_lock_array_object_at_index (io_lock_state->locks, i);
cc_uint32 has_pending_lock_for_client = 0;
err = ccs_lock_is_for_client_pipe (lock, in_client_pipe, &has_pending_lock_for_client);
if (!err && has_pending_lock_for_client) {
cci_debug_printf ("WARNING %s: Removing unexpected pending lock %p at index %d.",
__FUNCTION__, lock, (int) i);
err = ccs_lock_status_remove_lock (io_lock_state, i);
if (!err) {
i--; /* We removed one so back up an index */
}
}
}
}
if (!err) {
err = ccs_lock_state_check_pending_lock (io_lock_state, in_client_pipe,
in_lock_type, &can_grant_lock_now);
}
if (!err) {
if (!can_grant_lock_now && (in_block == cc_lock_noblock)) {
err = cci_check_error (io_lock_state->pending_lock_err);
} else {
cc_uint64 new_lock_index = 0;
err = ccs_lock_status_add_pending_lock (io_lock_state,
in_client_pipe,
in_reply_pipe,
in_lock_type,
&new_lock_index);
if (!err && can_grant_lock_now) {
err = ccs_lock_status_grant_lock (io_lock_state, new_lock_index);
if (!err && (in_lock_type == cc_lock_downgrade)) {
/* downgrades can allow us to grant other locks */
err = ccs_lock_status_try_to_grant_pending_locks (io_lock_state);
}
}
}
}
if (!err) {
/* ccs_lock_state_add sends its replies via callback so caller shouldn't */
*out_will_send_reply = 1;
}
return cci_check_error (err);
}
