ReactOS 0.4.15-dev-5666-gc548b97
delegation.h File Reference
#include "nfs41.h"
Include dependency graph for delegation.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define DELEGATION_RETURN_ON_CONFLICT
 

Functions

void nfs41_delegation_ref (IN nfs41_delegation_state *state)
 
void nfs41_delegation_deref (IN nfs41_delegation_state *state)
 
void nfs41_client_delegation_free (IN nfs41_client *client)
 
int nfs41_delegation_granted (IN nfs41_session *session, IN nfs41_path_fh *parent, IN nfs41_path_fh *file, IN open_delegation4 *delegation, IN bool_t try_recovery, OUT nfs41_delegation_state **deleg_out)
 
int nfs41_delegate_open (IN nfs41_open_state *state, IN uint32_t create, IN OPTIONAL nfs41_file_info *createattrs, OUT nfs41_file_info *info)
 
int nfs41_delegation_to_open (IN nfs41_open_state *open, IN bool_t try_recovery)
 
void nfs41_delegation_remove_srvopen (IN nfs41_session *session, IN nfs41_path_fh *file)
 
int nfs41_delegation_return (IN nfs41_session *session, IN nfs41_path_fh *file, IN enum open_delegation_type4 access, IN bool_t truncate)
 
int nfs41_delegation_recall (IN nfs41_client *client, IN nfs41_fh *fh, IN const stateid4 *stateid, IN bool_t truncate)
 
int nfs41_delegation_getattr (IN nfs41_client *client, IN const nfs41_fh *fh, IN const bitmap4 *attr_request, OUT nfs41_file_info *info)
 
int nfs41_client_delegation_recovery (IN nfs41_client *client)
 
int nfs41_client_delegation_return_lru (IN nfs41_client *client)
 

Macro Definition Documentation

◆ DELEGATION_RETURN_ON_CONFLICT

#define DELEGATION_RETURN_ON_CONFLICT

Definition at line 29 of file delegation.h.

Function Documentation

◆ nfs41_client_delegation_free()

void nfs41_client_delegation_free ( IN nfs41_client client)

Definition at line 828 of file delegation.c.

830{
831 struct list_entry *entry, *tmp;
832
833 EnterCriticalSection(&client->state.lock);
834 list_for_each_tmp (entry, tmp, &client->state.delegations) {
837 }
838 LeaveCriticalSection(&client->state.lock);
839}
static void list_remove(struct list_entry *entry)
Definition: list.h:90
#define list_for_each_tmp(entry, tmp, head)
Definition: list.h:39
#define deleg_entry(pos)
Definition: delegation.c:377
void nfs41_delegation_deref(IN nfs41_delegation_state *state)
Definition: delegation.c:79
uint32_t entry
Definition: isohybrid.c:63
static FILE * client
Definition: client.c:41
Definition: list.h:27
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)

Referenced by nfs41_client_free().

◆ nfs41_client_delegation_recovery()

int nfs41_client_delegation_recovery ( IN nfs41_client client)

Definition at line 861 of file delegation.c.

863{
864 struct list_entry *entry, *tmp;
866 int status = NFS4_OK;
867
868 list_for_each_tmp(entry, tmp, &client->state.delegations) {
870
872 switch (status) {
874 /* the delegation was reclaimed, but flagged as recalled;
875 * return it with try_recovery=FALSE */
877 break;
878
880 /* reclaim failed, so we have no delegation state on the server;
881 * 'forget' the delegation without trying to return it */
883 status = NFS4_OK;
884 break;
885 }
886
888 goto out;
889 }
890
891 /* use DELEGPURGE to indicate that we're done reclaiming delegations */
892 status = nfs41_delegpurge(client->session);
893
894 /* support for DELEGPURGE is optional; ignore any errors but BADSESSION */
896 status = NFS4_OK;
897out:
898 return status;
899}
#define list_container(entry, type, field)
Definition: list.h:33
static void delegation_remove(IN nfs41_client *client, IN nfs41_delegation_state *deleg)
Definition: delegation.c:91
static int delegation_return(IN nfs41_client *client, IN nfs41_delegation_state *deleg, IN bool_t truncate, IN bool_t try_recovery)
Definition: delegation.c:264
static int delegation_recovery_status(IN nfs41_delegation_state *deleg)
Definition: delegation.c:842
#define FALSE
Definition: types.h:117
#define client_entry(pos)
Definition: namespace.c:33
@ NFS4ERR_DELEG_REVOKED
Definition: nfs41_const.h:196
@ NFS4ERR_BADSESSION
Definition: nfs41_const.h:161
@ NFS4_OK
Definition: nfs41_const.h:87
@ NFS4ERR_BADHANDLE
Definition: nfs41_const.h:107
int nfs41_delegpurge(IN nfs41_session *session)
Definition: nfs41_ops.c:1666
static FILE * out
Definition: regtests2xml.c:44
Definition: ps.c:97

Referenced by nfs41_client_state_revoked(), and nfs41_recover_client_state().

◆ nfs41_client_delegation_return_lru()

int nfs41_client_delegation_return_lru ( IN nfs41_client client)

Definition at line 902 of file delegation.c.

904{
905 struct list_entry *entry;
908
909 /* starting from the least recently opened, find and return
910 * the first delegation that's not 'in use' (currently open) */
911
912 /* TODO: use a more robust algorithm, taking into account:
913 * -number of total opens
914 * -time since last operation on an associated open, or
915 * -number of operations/second over last n seconds */
916 EnterCriticalSection(&client->state.lock);
917 list_for_each(entry, &client->state.delegations) {
919
920 /* skip if it's currently in use for an open; note that ref_count
921 * can't go from 1 to 2 without holding client->state.lock */
922 if (state->ref_count > 1)
923 continue;
924
926 if (state->status == DELEGATION_GRANTED) {
927 /* start returning the delegation */
928 state->status = DELEGATION_RETURNING;
930 }
932
934 break;
935 }
936 LeaveCriticalSection(&client->state.lock);
937
940 return status;
941}
static int state
Definition: maze.c:121
#define list_for_each(entry, head)
Definition: list.h:36
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
VOID WINAPI AcquireSRWLockExclusive(PSRWLOCK Lock)
Definition: sync.c:54
VOID WINAPI ReleaseSRWLockExclusive(PSRWLOCK Lock)
Definition: sync.c:82
@ DELEGATION_GRANTED
Definition: nfs41.h:90
@ DELEGATION_RETURNING
Definition: nfs41.h:91

Referenced by open_update_cache().

◆ nfs41_delegate_open()

int nfs41_delegate_open ( IN nfs41_open_state state,
IN uint32_t  create,
IN OPTIONAL nfs41_file_info createattrs,
OUT nfs41_file_info info 
)

Definition at line 462 of file delegation.c.

467{
468 nfs41_client *client = state->session->client;
469 nfs41_path_fh *file = &state->file;
470 uint32_t access = state->share_access;
471 uint32_t deny = state->share_deny;
473 stateid_arg stateid;
474 int status;
475
476 /* search for a delegation with this filehandle */
478 if (status)
479 goto out;
480
482 if (deleg->status != DELEGATION_GRANTED) {
483 /* the delegation is being returned, wait for it to finish */
484 while (deleg->status != DELEGATION_RETURNED)
485 SleepConditionVariableSRW(&deleg->cond, &deleg->lock, INFINITE, 0);
487 }
488 else if (!delegation_compatible(deleg->state.type, create, access, deny)) {
489#ifdef DELEGATION_RETURN_ON_CONFLICT
490 /* this open will conflict, start the delegation return */
493#else
495#endif
496 } else if (create == OPEN4_CREATE) {
497 /* copy the stateid for SETATTR */
498 stateid.open = NULL;
499 stateid.delegation = deleg;
500 stateid.type = STATEID_DELEG_FILE;
501 memcpy(&stateid.stateid, &deleg->state.stateid, sizeof(stateid4));
502 }
503 if (!status) {
504 dprintf(1, "nfs41_delegate_open: updating srv_open from %x to %x\n",
505 deleg->srv_open, state->srv_open);
506 deleg->srv_open = state->srv_open;
507 }
509
511 goto out_return;
512 if (status)
513 goto out_deleg;
514
515 if (create == OPEN4_CREATE) {
516 memcpy(info, createattrs, sizeof(nfs41_file_info));
517
518 /* write delegations allow us to simulate OPEN4_CREATE with SETATTR */
519 status = delegation_truncate(deleg, client, &stateid, info);
520 if (status)
521 goto out_deleg;
522 }
523
524 /* TODO: check access against deleg->state.permissions or send ACCESS */
525
526 state->delegation.state = deleg;
527 status = NFS4_OK;
528out:
529 return status;
530
531out_return:
533
534out_deleg:
536 goto out;
537}
static int deleg_file_cmp(const struct list_entry *entry, const void *value)
Definition: delegation.c:379
static int delegation_truncate(IN nfs41_delegation_state *deleg, IN nfs41_client *client, IN stateid_arg *stateid, IN nfs41_file_info *info)
Definition: delegation.c:440
static bool_t delegation_compatible(IN enum open_delegation_type4 type, IN uint32_t create, IN uint32_t access, IN uint32_t deny)
Definition: delegation.c:388
static int delegation_find(IN nfs41_client *client, IN const void *value, IN list_compare_fn cmp, OUT nfs41_delegation_state **deleg_out)
Definition: delegation.c:415
UINT32 uint32_t
Definition: types.h:75
BOOL WINAPI SleepConditionVariableSRW(PCONDITION_VARIABLE ConditionVariable, PSRWLOCK Lock, DWORD Timeout, ULONG Flags)
Definition: sync.c:121
#define INFINITE
Definition: serial.h:102
GLuint GLint GLboolean GLint GLenum access
Definition: glext.h:7866
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static const struct access_res create[16]
Definition: package.c:7644
@ DELEGATION_RETURNED
Definition: nfs41.h:92
@ OPEN4_CREATE
Definition: nfs41_ops.h:554
@ STATEID_DELEG_FILE
Definition: nfs41_ops.h:278
#define dprintf
Definition: regdump.c:33
enum delegation_status status
Definition: nfs41.h:103
open_delegation4 state
Definition: nfs41.h:96
CONDITION_VARIABLE cond
Definition: nfs41.h:105
enum open_delegation_type4 type
Definition: nfs41_types.h:154
enum stateid_type type
Definition: nfs41_ops.h:285
nfs41_open_state * open
Definition: nfs41_ops.h:286
stateid4 stateid
Definition: nfs41_ops.h:284
nfs41_delegation_state * delegation
Definition: nfs41_ops.h:287
Definition: fci.c:127

Referenced by open_or_delegate().

◆ nfs41_delegation_deref()

void nfs41_delegation_deref ( IN nfs41_delegation_state state)

Definition at line 79 of file delegation.c.

81{
82 const LONG count = InterlockedDecrement(&state->ref_count);
83 dprintf(DGLVL, "nfs41_delegation_deref(%s) count %d\n",
84 state->path.path, count);
85 if (count == 0)
86 free(state);
87}
#define InterlockedDecrement
Definition: armddk.h:52
#define free
Definition: debug_ros.c:5
#define DGLVL
Definition: delegation.c:32
GLuint GLuint GLsizei count
Definition: gl.h:1545
long LONG
Definition: pedump.c:60

Referenced by delegation_recall_thread(), delegation_remove(), nfs41_client_delegation_free(), nfs41_delegate_open(), nfs41_delegation_getattr(), nfs41_delegation_recall(), nfs41_delegation_remove_srvopen(), nfs41_delegation_return(), and open_state_free().

◆ nfs41_delegation_getattr()

int nfs41_delegation_getattr ( IN nfs41_client client,
IN const nfs41_fh fh,
IN const bitmap4 attr_request,
OUT nfs41_file_info info 
)

Definition at line 783 of file delegation.c.

788{
790 uint64_t fileid;
791 int status;
792
793 dprintf(2, "--> nfs41_delegation_getattr()\n");
794
795 /* search for a delegation on this file handle */
797 if (status)
798 goto out;
799
800 AcquireSRWLockShared(&deleg->lock);
801 fileid = deleg->file.fh.fileid;
802 if (deleg->status != DELEGATION_GRANTED ||
803 deleg->state.type != OPEN_DELEGATE_WRITE) {
805 }
806 ReleaseSRWLockShared(&deleg->lock);
807 if (status)
808 goto out_deleg;
809
811
812 /* find attributes for the given fileid */
814 client_name_cache(client), fileid, info);
815 if (status) {
817 goto out_deleg;
818 }
819out_deleg:
821out:
822 dprintf(DGLVL, "<-- nfs41_delegation_getattr() returning %s\n",
824 return status;
825}
const char * nfs_error_string(int status)
Definition: daemon_debug.c:370
static int deleg_fh_cmp(const struct list_entry *entry, const void *value)
Definition: delegation.c:775
UINT64 uint64_t
Definition: types.h:77
VOID WINAPI ReleaseSRWLockShared(PSRWLOCK Lock)
Definition: sync.c:89
VOID WINAPI AcquireSRWLockShared(PSRWLOCK Lock)
Definition: sync.c:61
int nfs41_attr_cache_lookup(IN struct nfs41_name_cache *cache, IN uint64_t fileid, OUT nfs41_file_info *info_out)
Definition: name_cache.c:859
static __inline struct nfs41_name_cache * client_name_cache(IN nfs41_client *client)
Definition: name_cache.h:28
@ OPEN_DELEGATE_WRITE
Definition: nfs41_ops.h:588
nfs41_path_fh file
Definition: nfs41.h:99
uint64_t fileid
Definition: nfs41_types.h:55
#define ZeroMemory
Definition: winbase.h:1670

Referenced by handle_cb_getattr().

◆ nfs41_delegation_granted()

int nfs41_delegation_granted ( IN nfs41_session session,
IN nfs41_path_fh parent,
IN nfs41_path_fh file,
IN open_delegation4 delegation,
IN bool_t  try_recovery,
OUT nfs41_delegation_state **  deleg_out 
)

Definition at line 330 of file delegation.c.

337{
338 stateid_arg stateid;
339 nfs41_client *client = session->client;
341 int status = NO_ERROR;
342
343 if (delegation->type != OPEN_DELEGATE_READ &&
344 delegation->type != OPEN_DELEGATE_WRITE)
345 goto out;
346
347 if (delegation->recalled) {
349 goto out_return;
350 }
351
352 /* allocate the delegation state */
353 status = delegation_create(parent, file, delegation, &state);
354 if (status)
355 goto out_return;
356
357 /* register the delegation with the client */
358 EnterCriticalSection(&client->state.lock);
359 /* XXX: check for duplicates by fh and stateid? */
360 list_add_tail(&client->state.delegations, &state->client_entry);
361 LeaveCriticalSection(&client->state.lock);
362
363 nfs41_delegation_ref(state); /* return a reference */
364 *deleg_out = state;
365out:
366 return status;
367
368out_return: /* return the delegation on failure */
369 memcpy(&stateid.stateid, &delegation->stateid, sizeof(stateid4));
370 stateid.type = STATEID_DELEG_FILE;
371 stateid.open = NULL;
372 stateid.delegation = NULL;
373 nfs41_delegreturn(session, file, &stateid, try_recovery);
374 goto out;
375}
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
#define NO_ERROR
Definition: dderror.h:5
static int delegation_create(IN const nfs41_path_fh *parent, IN const nfs41_path_fh *file, IN const open_delegation4 *delegation, OUT nfs41_delegation_state **deleg_out)
Definition: delegation.c:36
void nfs41_delegation_ref(IN nfs41_delegation_state *state)
Definition: delegation.c:71
r parent
Definition: btrfs.c:3010
int nfs41_delegreturn(IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid, IN bool_t try_recovery)
Definition: nfs41_ops.c:1693
@ OPEN_DELEGATE_READ
Definition: nfs41_ops.h:587

Referenced by do_open(), and recover_open().

◆ nfs41_delegation_recall()

int nfs41_delegation_recall ( IN nfs41_client client,
IN nfs41_fh fh,
IN const stateid4 stateid,
IN bool_t  truncate 
)

Definition at line 703 of file delegation.c.

708{
710 struct recall_thread_args *args;
711 int status;
712
713 dprintf(2, "--> nfs41_delegation_recall()\n");
714
715 /* search for the delegation by stateid instead of filehandle;
716 * deleg_file_cmp() relies on a proper superblock and fileid,
717 * which we don't get with CB_RECALL */
718 status = delegation_find(client, stateid, deleg_stateid_cmp, &deleg);
719 if (status)
720 goto out;
721
723 if (deleg->state.recalled) {
724 /* return BADHANDLE if we've already responded to CB_RECALL */
726 } else {
727 deleg->state.recalled = 1;
728
729 if (deleg->status == DELEGATION_GRANTED) {
730 /* start the delegation return */
733 } /* else return NFS4_OK */
734 }
736
738 goto out_deleg;
739
740 /* allocate thread arguments */
741 args = calloc(1, sizeof(struct recall_thread_args));
742 if (args == NULL) {
744 eprintf("nfs41_delegation_recall() failed to allocate arguments\n");
745 goto out_deleg;
746 }
747
748 /* hold a reference on the root */
749 nfs41_root_ref(client->root);
750 args->client = client;
751 args->delegation = deleg;
752 args->truncate = truncate;
753
754 /* the callback thread can't make rpc calls, so spawn a separate thread */
757 eprintf("nfs41_delegation_recall() failed to start thread\n");
758 goto out_args;
759 }
760 status = NFS4_OK;
761out:
762 dprintf(DGLVL, "<-- nfs41_delegation_recall() returning %s\n",
764 return status;
765
766out_args:
767 free(args);
769out_deleg:
771 goto out;
772}
void eprintf(LPCSTR format,...)
Definition: daemon_debug.c:86
static int deleg_stateid_cmp(const struct list_entry *entry, const void *value)
Definition: delegation.c:696
static unsigned int WINAPI delegation_recall_thread(void *args)
Definition: delegation.c:683
void nfs41_root_ref(IN nfs41_root *root)
Definition: namespace.c:92
void nfs41_root_deref(IN nfs41_root *root)
Definition: namespace.c:100
@ NFS4ERR_SERVERFAULT
Definition: nfs41_const.h:111
#define calloc
Definition: rosglue.h:14
_CRTIMP uintptr_t __cdecl _beginthreadex(_In_opt_ void *_Security, _In_ unsigned _StackSize, _In_ unsigned(__stdcall *_StartAddress)(void *), _In_opt_ void *_ArgList, _In_ unsigned _InitFlag, _Out_opt_ unsigned *_ThrdAddr)
#define args
Definition: format.c:66
Definition: match.c:390

Referenced by handle_cb_recall().

◆ nfs41_delegation_ref()

void nfs41_delegation_ref ( IN nfs41_delegation_state state)

Definition at line 71 of file delegation.c.

73{
74 const LONG count = InterlockedIncrement(&state->ref_count);
75 dprintf(DGLVL, "nfs41_delegation_ref(%s) count %d\n",
76 state->path.path, count);
77}
#define InterlockedIncrement
Definition: armddk.h:53

Referenced by delegation_find(), and nfs41_delegation_granted().

◆ nfs41_delegation_remove_srvopen()

void nfs41_delegation_remove_srvopen ( IN nfs41_session session,
IN nfs41_path_fh file 
)

Definition at line 610 of file delegation.c.

613{
615
616 /* find a delegation for this file */
617 if (delegation_find(session->client, &file->fh, deleg_file_cmp, &deleg))
618 return;
619 dprintf(1, "nfs41_delegation_remove_srvopen: removing reference to "
620 "srv_open=%x\n", deleg->srv_open);
622 deleg->srv_open = NULL;
625}

Referenced by handle_close().

◆ nfs41_delegation_return()

int nfs41_delegation_return ( IN nfs41_session session,
IN nfs41_path_fh file,
IN enum open_delegation_type4  access,
IN bool_t  truncate 
)

Definition at line 629 of file delegation.c.

638{
639 nfs41_client *client = session->client;
641 int status;
642
643 /* find a delegation for this file */
645 if (status)
646 goto out;
647
649 if (deleg->status == DELEGATION_GRANTED) {
650 /* return unless delegation is write and access is read */
651 if (deleg->state.type != OPEN_DELEGATE_WRITE
655 }
656 } else {
657 /* the delegation is being returned, wait for it to finish */
658 while (deleg->status == DELEGATION_RETURNING)
659 SleepConditionVariableSRW(&deleg->cond, &deleg->lock, INFINITE, 0);
661 }
663
665 delegation_return(client, deleg, truncate, TRUE);
666 status = NFS4_OK;
667 }
668
670out:
671 return status;
672}

Referenced by cancel_open(), handle_close(), handle_nfs41_remove(), handle_nfs41_set_size(), handle_open(), handle_setacl(), and handle_setexattr().

◆ nfs41_delegation_to_open()

int nfs41_delegation_to_open ( IN nfs41_open_state open,
IN bool_t  try_recovery 
)

Definition at line 539 of file delegation.c.

542{
543 open_delegation4 ignore;
544 open_claim4 claim;
545 stateid4 open_stateid = { 0 };
546 stateid_arg deleg_stateid;
547 int status = NFS4_OK;
548
550 if (open->delegation.state == NULL) /* no delegation to reclaim */
551 goto out_unlock;
552
553 if (open->do_close) /* already have an open stateid */
554 goto out_unlock;
555
556 /* if another thread is reclaiming the open stateid,
557 * wait for it to finish before returning success */
558 if (open->delegation.reclaim) {
559 do {
560 SleepConditionVariableSRW(&open->delegation.cond, &open->lock,
561 INFINITE, 0);
562 } while (open->delegation.reclaim);
563 if (open->do_close)
564 goto out_unlock;
565 }
566 open->delegation.reclaim = 1;
567
568 AcquireSRWLockShared(&open->delegation.state->lock);
569 deleg_stateid.open = open;
570 deleg_stateid.delegation = NULL;
571 deleg_stateid.type = STATEID_DELEG_FILE;
572 memcpy(&deleg_stateid.stateid, &open->delegation.state->state.stateid,
573 sizeof(stateid4));
574 ReleaseSRWLockShared(&open->delegation.state->lock);
575
577
578 /* send OPEN with CLAIM_DELEGATE_CUR */
580 claim.u.deleg_cur.delegate_stateid = &deleg_stateid;
581 claim.u.deleg_cur.name = &open->file.name;
582
583 status = nfs41_open(open->session, &open->parent, &open->file,
584 &open->owner, &claim, open->share_access, open->share_deny,
585 OPEN4_NOCREATE, 0, NULL, try_recovery, &open_stateid, &ignore, NULL);
586
588 if (status == NFS4_OK) {
589 /* save the new open stateid */
590 memcpy(&open->stateid, &open_stateid, sizeof(stateid4));
591 open->do_close = 1;
592 } else if (open->do_close && (status == NFS4ERR_BAD_STATEID ||
594 /* something triggered client state recovery, and the open stateid
595 * has already been reclaimed; see recover_stateid_delegation() */
596 status = NFS4_OK;
597 }
598 open->delegation.reclaim = 0;
599
600 /* signal anyone waiting on the open stateid */
601 WakeAllConditionVariable(&open->delegation.cond);
602out_unlock:
604 if (status)
605 eprintf("nfs41_delegation_to_open(%p) failed with %s\n",
607 return status;
608}
#define open
Definition: acwin.h:95
VOID WINAPI WakeAllConditionVariable(PCONDITION_VARIABLE ConditionVariable)
Definition: sync.c:137
@ NFS4ERR_BAD_STATEID
Definition: nfs41_const.h:132
@ NFS4ERR_EXPIRED
Definition: nfs41_const.h:116
@ NFS4ERR_STALE_STATEID
Definition: nfs41_const.h:130
int nfs41_open(IN nfs41_session *session, IN nfs41_path_fh *parent, IN nfs41_path_fh *file, IN state_owner4 *owner, IN open_claim4 *claim, IN uint32_t allow, IN uint32_t deny, IN uint32_t create, IN uint32_t how_mode, IN OPTIONAL nfs41_file_info *createattrs, IN bool_t try_recovery, OUT stateid4 *stateid, OUT open_delegation4 *delegation, OUT OPTIONAL nfs41_file_info *info)
Definition: nfs41_ops.c:366
@ OPEN4_NOCREATE
Definition: nfs41_ops.h:553
@ CLAIM_DELEGATE_CUR
Definition: nfs41_ops.h:595
uint32_t claim
Definition: nfs41_ops.h:615
union __open_claim4::@41 u
struct __open_claim4::@41::__open_claim_deleg_cur deleg_cur
char * name
Definition: compiler.c:66

Referenced by delegation_return(), and handle_lock().