state_owner_t *get_9p_owner(struct sockaddr_storage *client_addr, uint32_t proc_id) { state_owner_t key; memset(&key, 0, sizeof(key)); key.so_type = STATE_LOCK_OWNER_9P; key.so_refcount = 1; key.so_owner.so_9p_owner.proc_id = proc_id; memcpy(&key.so_owner.so_9p_owner.client_addr, client_addr, sizeof(*client_addr)); return get_state_owner(CARE_ALWAYS, &key, NULL, NULL); }
/** * @brief Get an NLM owner * * @param[in] care Care status * @param[in] client Related NLM client * @param[in] oh Object handle * @param[in] svid Owner ID */ state_owner_t *get_nlm_owner(care_t care, state_nlm_client_t *client, netobj *oh, uint32_t svid) { state_owner_t key; if (client == NULL || oh == NULL || oh->n_len > MAX_NETOBJ_SZ) return NULL; memset(&key, 0, sizeof(key)); key.so_type = STATE_LOCK_OWNER_NLM; key.so_owner.so_nlm_owner.so_client = client; key.so_owner.so_nlm_owner.so_nlm_svid = svid; key.so_owner_len = oh->n_len; key.so_owner_val = oh->n_bytes; return get_state_owner(care, &key, init_nlm_owner, NULL); }
/** * @brief Create an NFSv4 state owner * * @param[in] name Owner name * @param[in] clientid Client record * @param[in] type Owner type * @param[in] related_owner For lock owners, the related open owner * @param[in] init_seqid The starting seqid (for NFSv4.0) * @param[out] pisnew Whether the owner actually is new * @param[in] care Care flag (to unify v3/v4 owners?) * * @return A new state owner or NULL. */ state_owner_t *create_nfs4_owner(state_nfs4_owner_name_t *name, nfs_client_id_t *clientid, state_owner_type_t type, state_owner_t *related_owner, unsigned int init_seqid, bool_t *pisnew, care_t care) { state_owner_t key; state_owner_t *owner; bool_t isnew; /* set up the content of the open_owner */ memset(&key, 0, sizeof(key)); key.so_type = type; key.so_owner.so_nfs4_owner.so_seqid = init_seqid; key.so_owner.so_nfs4_owner.so_related_owner = related_owner; key.so_owner.so_nfs4_owner.so_clientid = clientid->cid_clientid; key.so_owner.so_nfs4_owner.so_clientrec = clientid; key.so_owner_len = name->son_owner_len; key.so_owner_val = name->son_owner_val; key.so_owner.so_nfs4_owner.so_resp.resop = NFS4_OP_ILLEGAL; key.so_owner.so_nfs4_owner.so_args.argop = NFS4_OP_ILLEGAL; key.so_refcount = 1; #if 0 /* WAITING FOR COMMUNITY FIX */ /* setting lock owner confirmed */ if (type == STATE_LOCK_OWNER_NFSV4) key.so_owner.so_nfs4_owner.so_confirmed = 1; #endif if (isFullDebug(COMPONENT_STATE)) { char str[LOG_BUFF_LEN]; struct display_buffer dspbuf = {sizeof(str), str, str}; display_owner(&dspbuf, &key); LogFullDebug(COMPONENT_STATE, "Key=%s", str); } owner = get_state_owner(care, &key, init_nfs4_owner, &isnew); if (owner != NULL && related_owner != NULL) { PTHREAD_MUTEX_lock(&owner->so_mutex); /* Related owner already exists. */ if (owner->so_owner.so_nfs4_owner.so_related_owner == NULL) { /* Attach related owner to owner now that we know it. */ inc_state_owner_ref(related_owner); owner->so_owner.so_nfs4_owner.so_related_owner = related_owner; } else if (owner->so_owner.so_nfs4_owner.so_related_owner != related_owner) { char str1[LOG_BUFF_LEN / 2]; char str2[LOG_BUFF_LEN / 2]; struct display_buffer dspbuf1 = { sizeof(str1), str1, str1}; struct display_buffer dspbuf2 = { sizeof(str2), str2, str2}; display_owner(&dspbuf1, related_owner); display_owner(&dspbuf2, owner); LogCrit(COMPONENT_NFS_V4_LOCK, "Related {%s} doesn't match for {%s}", str1, str2); PTHREAD_MUTEX_unlock(&owner->so_mutex); /* Release the reference to the owner. */ dec_state_owner_ref(owner); return NULL; } PTHREAD_MUTEX_unlock(&owner->so_mutex); } if (!isnew && owner != NULL && pisnew != NULL) { if (isDebug(COMPONENT_STATE)) { char str[LOG_BUFF_LEN]; struct display_buffer dspbuf = {sizeof(str), str, str}; display_owner(&dspbuf, owner); LogDebug(COMPONENT_STATE, "Previously known owner {%s} is being reused", str); } } if (pisnew != NULL) *pisnew = isnew; return owner; }