nfs41.h File Reference

#include "util.h"
#include "list.h"

Include dependency graph for nfs41.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	__nfs41_superblock
struct	__nfs41_superblock_list
struct	server_addrs
struct	__nfs41_server
struct	__nfs41_delegation_state
struct	__nfs41_lock_state
struct	__nfs41_open_state
struct	__nfs41_rpc_clnt
struct	client_state
struct	__nfs41_client
struct	__nfs41_slot_table
struct	__nfs41_channel_attrs
struct	replay_cache
struct	__nfs41_cb_session
struct	__nfs41_session
struct	__nfs41_root

Macros
#define	NFS41_MAX_NUM_SLOTS   NFS41_MAX_RPC_REQS

Typedefs
typedef struct __nfs41_superblock	nfs41_superblock
typedef struct __nfs41_superblock_list	nfs41_superblock_list
typedef struct __nfs41_server	nfs41_server
typedef struct __nfs41_delegation_state	nfs41_delegation_state
typedef struct __nfs41_lock_state	nfs41_lock_state
typedef struct __nfs41_open_state	nfs41_open_state
typedef struct __nfs41_rpc_clnt	nfs41_rpc_clnt
typedef struct __nfs41_client	nfs41_client
typedef struct __nfs41_slot_table	nfs41_slot_table
typedef struct __nfs41_channel_attrs	nfs41_channel_attrs
typedef struct __nfs41_cb_session	nfs41_cb_session
typedef struct __nfs41_session	nfs41_session
typedef struct __nfs41_root	nfs41_root

Enumerations
enum	delegation_status { DELEGATION_GRANTED , DELEGATION_RETURNING , DELEGATION_RETURNED }

Functions
int	nfs41_root_create (IN const char *name, IN uint32_t sec_flavor, IN uint32_t wsize, IN uint32_t rsize, OUT nfs41_root **root_out)
void	nfs41_root_ref (IN nfs41_root *root)
void	nfs41_root_deref (IN nfs41_root *root)
int	nfs41_root_mount_addrs (IN nfs41_root *root, IN const multi_addr4 *addrs, IN bool_t is_data, IN OPTIONAL uint32_t lease_time, OUT nfs41_client **client_out)
int	nfs41_root_mount_server (IN nfs41_root *root, IN nfs41_server *server, IN bool_t is_data, IN OPTIONAL uint32_t lease_time, OUT nfs41_client **client_out)
int	nfs41_root_mount_referral (IN nfs41_root *root, IN const fs_locations4 *locations, OUT const fs_location4 **loc_out, OUT nfs41_client **client_out)
static __inline nfs41_session *	nfs41_root_session (IN nfs41_root *root)
int	nfs41_session_create (IN nfs41_client *client, IN nfs41_session **session_out)
int	nfs41_session_renew (IN nfs41_session *session)
int	nfs41_session_set_lease (IN nfs41_session *session, IN uint32_t lease_time)
void	nfs41_session_free (IN nfs41_session *session)
void	nfs41_session_bump_seq (IN nfs41_session *session, IN uint32_t slotid, IN uint32_t target_highest_slotid)
void	nfs41_session_free_slot (IN nfs41_session *session, IN uint32_t slotid)
void	nfs41_session_get_slot (IN nfs41_session *session, OUT uint32_t *slot, OUT uint32_t *seq, OUT uint32_t *highest)
int	nfs41_session_recall_slot (IN nfs41_session *session, IN OUT uint32_t target_highest_slotid)
void	nfs41_session_sequence (struct __nfs41_sequence_args *args, nfs41_session *session, bool_t cachethis)
int	nfs41_session_bad_slot (IN nfs41_session *session, IN OUT struct __nfs41_sequence_args *args)
void	nfs41_server_list_init ()
int	nfs41_server_resolve (IN const char *hostname, IN unsigned short port, OUT multi_addr4 *addrs)
int	nfs41_server_find_or_create (IN const char *server_owner_major_id, IN const char *server_scope, IN const netaddr4 *addr, OUT nfs41_server **server_out)
void	nfs41_server_ref (IN nfs41_server *server)
void	nfs41_server_deref (IN nfs41_server *server)
void	nfs41_server_addrs (IN nfs41_server *server, OUT multi_addr4 *addrs)
int	nfs41_client_owner (IN const char *name, IN uint32_t sec_flavor, OUT client_owner4 *owner)
uint32_t	nfs41_exchange_id_flags (IN bool_t is_data)
int	nfs41_client_create (IN nfs41_rpc_clnt *rpc, IN const client_owner4 *owner, IN bool_t is_data, IN const struct __nfs41_exchange_id_res *exchangeid, OUT nfs41_client **client_out)
int	nfs41_client_renew (IN nfs41_client *client)
void	nfs41_client_free (IN nfs41_client *client)
static __inline nfs41_server *	client_server (IN nfs41_client *client)
int	nfs41_superblock_for_fh (IN nfs41_session *session, IN const nfs41_fsid *fsid, IN const nfs41_fh *parent OPTIONAL, OUT nfs41_path_fh *file)
static __inline void	nfs41_superblock_getattr_mask (IN const nfs41_superblock *superblock, OUT bitmap4 *attrs)
static __inline void	nfs41_superblock_supported_attrs (IN const nfs41_superblock *superblock, IN OUT bitmap4 *attrs)
static __inline void	nfs41_superblock_supported_attrs_exclcreat (IN const nfs41_superblock *superblock, IN OUT bitmap4 *attrs)
void	nfs41_superblock_fs_attributes (IN const nfs41_superblock *superblock, OUT struct _FILE_FS_ATTRIBUTE_INFORMATION *FsAttrs)
void	nfs41_superblock_space_changed (IN nfs41_superblock *superblock)
void	nfs41_superblock_list_init (IN nfs41_superblock_list *superblocks)
void	nfs41_superblock_list_free (IN nfs41_superblock_list *superblocks)
int	nfs41_rpc_clnt_create (IN const multi_addr4 *addrs, IN uint32_t wsize, IN uint32_t rsize, IN uint32_t uid, IN uint32_t gid, IN uint32_t sec_flavor, OUT nfs41_rpc_clnt **rpc_out)
void	nfs41_rpc_clnt_free (IN nfs41_rpc_clnt *rpc)
int	nfs41_send_compound (IN nfs41_rpc_clnt *rpc, IN char *inbuf, OUT char *outbuf)
static __inline netaddr4 *	nfs41_rpc_netaddr (IN nfs41_rpc_clnt *rpc)
void	nfs41_open_state_ref (IN nfs41_open_state *state)
void	nfs41_open_state_deref (IN nfs41_open_state *state)
void	nfs41_open_stateid_arg (IN nfs41_open_state *state, OUT struct __stateid_arg *arg)
int	nfs41_ea_set (IN nfs41_open_state *state, IN struct _FILE_FULL_EA_INFORMATION *ea)

Macro Definition Documentation

NFS41_MAX_NUM_SLOTS

#define NFS41_MAX_NUM_SLOTS   NFS41_MAX_RPC_REQS

Definition at line 218 of file nfs41.h.

Typedef Documentation

nfs41_cb_session

typedef struct __nfs41_cb_session nfs41_cb_session

nfs41_channel_attrs

typedef struct __nfs41_channel_attrs nfs41_channel_attrs

nfs41_client

typedef struct __nfs41_client nfs41_client

nfs41_delegation_state

typedef struct __nfs41_delegation_state nfs41_delegation_state

nfs41_lock_state

typedef struct __nfs41_lock_state nfs41_lock_state

nfs41_open_state

typedef struct __nfs41_open_state nfs41_open_state

nfs41_root

typedef struct __nfs41_root nfs41_root

nfs41_rpc_clnt

typedef struct __nfs41_rpc_clnt nfs41_rpc_clnt

nfs41_server

typedef struct __nfs41_server nfs41_server

nfs41_session

typedef struct __nfs41_session nfs41_session

nfs41_slot_table

typedef struct __nfs41_slot_table nfs41_slot_table

nfs41_superblock

typedef struct __nfs41_superblock nfs41_superblock

nfs41_superblock_list

typedef struct __nfs41_superblock_list nfs41_superblock_list

Enumeration Type Documentation

delegation_status

enum delegation_status

Enumerator
DELEGATION_GRANTED
DELEGATION_RETURNING
DELEGATION_RETURNED

Definition at line 89 of file nfs41.h.

                       {
    DELEGATION_GRANTED,
    DELEGATION_RETURNING,
    DELEGATION_RETURNED,
};

Function Documentation

client_server()

static __inline nfs41_server * client_server ( IN nfs41_client *  client )

static

Definition at line 428 of file nfs41.h.

{
    /* the client's server could change during nfs41_client_renew(),
     * so access to client->server must be protected */
    nfs41_server *server;
    AcquireSRWLockShared(&client->exid_lock);
    server = client->server;
    ReleaseSRWLockShared(&client->exid_lock);
    return server;
}

Referenced by client_name_cache(), and nfs41_superblock_for_fh().

nfs41_client_create()

int nfs41_client_create	(	IN nfs41_rpc_clnt *	rpc,
		IN const client_owner4 *	owner,
		IN bool_t	is_data,
		IN const struct __nfs41_exchange_id_res *	exchangeid,
		OUT nfs41_client **	client_out
	)

Referenced by root_client_create().

nfs41_client_free()

void nfs41_client_free

(

IN nfs41_client *

client

)

Definition at line 206 of file nfs41_client.c.

{
    dprintf(2, "nfs41_client_free(%llu)\n", client->clnt_id);
    nfs41_client_delegation_free(client);
    if (client->session) nfs41_session_free(client->session);
    nfs41_destroy_clientid(client->rpc, client->clnt_id);
    if (client->server) nfs41_server_deref(client->server);
    nfs41_rpc_clnt_free(client->rpc);
    if (client->layouts) pnfs_layout_list_free(client->layouts);
    if (client->devices) pnfs_file_device_list_free(client->devices);
    DeleteCriticalSection(&client->state.lock);
    DeleteCriticalSection(&client->recovery.lock);
    free(client);
}

Referenced by nfs41_client_create(), nfs41_root_mount_addrs(), root_client_create(), and root_free().

nfs41_client_owner()

int nfs41_client_owner	(	IN const char *	name,
		IN uint32_t	sec_flavor,
		OUT client_owner4 *	owner
	)

Definition at line 358 of file nfs41_client.c.

{
    HCRYPTPROV context;
    HCRYPTHASH hash;
    PBYTE buffer;
    DWORD length;
    const ULONGLONG time_created = GetTickCount64();
    int status;
    char username[UNLEN + 1];
    DWORD len = UNLEN + 1;
 
    if (!GetUserNameA(username, &len)) {
        status = GetLastError();
        eprintf("GetUserName() failed with %d\n", status);
        goto out;
    }
 
    /* owner.verifier = "time created" */
    memcpy(owner->co_verifier, &time_created, sizeof(time_created));
 
    /* set up the md5 hash generator */
    if (!CryptAcquireContext(&context, NULL, NULL,
        PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
        status = GetLastError();
        eprintf("CryptAcquireContext() failed with %d\n", status);
        goto out;
    }
    if (!CryptCreateHash(context, CALG_MD5, 0, 0, &hash)) {
        status = GetLastError();
        eprintf("CryptCreateHash() failed with %d\n", status);
        goto out_context;
    }
 
    if (!CryptHashData(hash, (const BYTE*)&sec_flavor, (DWORD)sizeof(sec_flavor), 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    if (!CryptHashData(hash, (const BYTE*)username, (DWORD)strlen(username), 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    if (!CryptHashData(hash, (const BYTE*)name, (DWORD)strlen(name), 0)) {
        status = GetLastError();
        eprintf("CryptHashData() failed with %d\n", status);
        goto out_hash;
    }
 
    /* add the mac address from each applicable adapter to the hash */
    status = hash_mac_addrs(hash);
    if (status) {
        eprintf("hash_mac_addrs() failed with %d\n", status);
        goto out_hash;
    }
 
    /* extract the hash size (should always be 16 for md5) */
    buffer = (PBYTE)&owner->co_ownerid_len;
    length = (DWORD)sizeof(DWORD);
    if (!CryptGetHashParam(hash, HP_HASHSIZE, buffer, &length, 0)) {
        status = GetLastError();
        eprintf("CryptGetHashParam(size) failed with %d\n", status);
        goto out_hash;
    }
    /* extract the hash buffer */
    buffer = owner->co_ownerid;
    length = owner->co_ownerid_len;
    if (!CryptGetHashParam(hash, HP_HASHVAL, buffer, &length, 0)) {
        status = GetLastError();
        eprintf("CryptGetHashParam(val) failed with %d\n", status);
        goto out_hash;
    }
 
out_hash:
    CryptDestroyHash(hash);
out_context:
    CryptReleaseContext(context, 0);
out:
    return status;
}

Referenced by nfs41_root_create().

nfs41_client_renew()

int nfs41_client_renew

(

IN nfs41_client *

client

)

Definition at line 168 of file nfs41_client.c.

{
    nfs41_exchange_id_res exchangeid = { 0 };
    int status;
 
    status = nfs41_exchange_id(client->rpc, &client->owner,
        nfs41_exchange_id_flags(client->is_data), &exchangeid);
    if (status) {
        eprintf("nfs41_exchange_id() failed with %d\n", status);
        status = ERROR_BAD_NET_RESP;
        goto out;
    }
 
    if (client->is_data) { /* require USE_PNFS_DS */
        if ((exchangeid.flags & EXCHGID4_FLAG_USE_PNFS_DS) == 0) {
            eprintf("client expected USE_PNFS_DS\n");
            status = ERROR_BAD_NET_RESP;
            goto out;
        }
    } else { /* require USE_NON_PNFS or USE_PNFS_MDS */
        if ((exchangeid.flags & EXCHGID4_FLAG_USE_NON_PNFS) == 0 &&
            (exchangeid.flags & EXCHGID4_FLAG_USE_PNFS_MDS) == 0) {
            eprintf("client expected USE_NON_PNFS OR USE_PNFS_MDS\n");
            status = ERROR_BAD_NET_RESP;
            goto out;
        }
    }
 
    dprint_roles(2, exchangeid.flags);
 
    AcquireSRWLockExclusive(&client->exid_lock);
    status = update_exchangeid_res(client, &exchangeid);
    ReleaseSRWLockExclusive(&client->exid_lock);
out:
    return status;
}

Referenced by compound_encode_send_decode(), and nfs41_recover_session().

nfs41_ea_set()

int nfs41_ea_set	(	IN nfs41_open_state *	state,
		IN struct _FILE_FULL_EA_INFORMATION *	ea
	)

nfs41_exchange_id_flags()

uint32_t nfs41_exchange_id_flags

(

IN bool_t

is_data

)

Definition at line 36 of file nfs41_client.c.

{
    uint32_t flags = EXCHGID4_FLAG_SUPP_MOVED_REFER;
    if (is_data)
        flags |= EXCHGID4_FLAG_USE_PNFS_DS;
    else
        flags |= EXCHGID4_FLAG_USE_NON_PNFS | EXCHGID4_FLAG_USE_PNFS_MDS;
    return flags;
}

Referenced by nfs41_client_renew(), nfs41_root_mount_addrs(), root_client_find(), and root_client_find_addrs().

nfs41_open_state_deref()

void nfs41_open_state_deref

(

IN nfs41_open_state *

state

)

Definition at line 104 of file open.c.

{
    const LONG count = InterlockedDecrement(&state->ref_count);
 
    dprintf(2, "nfs41_open_state_deref(%s) count %d\n", state->path.path, count);
    if (count == 0)
        open_state_free(state);
}

Referenced by cancel_open(), cleanup_close(), delegation_return(), handle_open(), and upcall_cleanup().

nfs41_open_state_ref()

void nfs41_open_state_ref

(

IN nfs41_open_state *

state

)

Definition at line 96 of file open.c.

{
    const LONG count = InterlockedIncrement(&state->ref_count);
 
    dprintf(2, "nfs41_open_state_ref(%s) count %d\n", state->path.path, count);
}

Referenced by deleg_open_find(), handle_open(), and upcall_parse().

nfs41_open_stateid_arg()

void nfs41_open_stateid_arg	(	IN nfs41_open_state *	state,
		OUT struct __stateid_arg *	arg
	)

Referenced by handle_nfs41_set_size(), handle_read(), handle_setacl(), handle_setexattr(), and handle_write().

nfs41_root_create()

int nfs41_root_create	(	IN const char *	name,
		IN uint32_t	sec_flavor,
		IN uint32_t	wsize,
		IN uint32_t	rsize,
		OUT nfs41_root **	root_out
	)

Definition at line 37 of file namespace.c.

{
    int status = NO_ERROR;
    nfs41_root *root;
 
    dprintf(NSLVL, "--> nfs41_root_create()\n");
 
    root = calloc(1, sizeof(nfs41_root));
    if (root == NULL) {
        status = GetLastError();
        goto out;
    }
 
    list_init(&root->clients);
    root->wsize = wsize;
    root->rsize = rsize;
    InitializeCriticalSection(&root->lock);
    root->ref_count = 1;
    root->sec_flavor = sec_flavor;
 
    /* generate a unique client_owner */
    status = nfs41_client_owner(name, sec_flavor, &root->client_owner);
    if (status) {
        eprintf("nfs41_client_owner() failed with %d\n", status);
        free(root);
        goto out;
    }
 
    *root_out = root;
out:
    dprintf(NSLVL, "<-- nfs41_root_create() returning %d\n", status);
    return status;
}

Referenced by handle_mount().

nfs41_root_deref()

void nfs41_root_deref

(

IN nfs41_root *

root

)

Definition at line 100 of file namespace.c.

{
    const LONG count = InterlockedDecrement(&root->ref_count);
 
    dprintf(NSLVL, "nfs41_root_deref() count %d\n", count);
    if (count == 0)
        root_free(root);
}

Referenced by cancel_mount(), delegation_recall_thread(), handle_mount(), handle_unmount(), nfs41_delegation_recall(), and upcall_cleanup().

nfs41_root_mount_addrs()

int nfs41_root_mount_addrs	(	IN nfs41_root *	root,
		IN const multi_addr4 *	addrs,
		IN bool_t	is_data,
		IN OPTIONAL uint32_t	lease_time,
		OUT nfs41_client **	client_out
	)

Definition at line 335 of file namespace.c.

{
    nfs41_exchange_id_res exchangeid = { 0 };
    nfs41_rpc_clnt *rpc;
    nfs41_client *client, *existing;
    int status;
 
    dprintf(NSLVL, "--> nfs41_root_mount_addrs()\n");
 
    /* look for an existing client that matches the address and role */
    EnterCriticalSection(&root->lock);
    status = root_client_find_addrs(root, addrs, is_data, &client);
    LeaveCriticalSection(&root->lock);
 
    if (status == NO_ERROR)
        goto out;
 
    /* create an rpc client */
    status = nfs41_rpc_clnt_create(addrs, root->wsize, root->rsize,
        root->uid, root->gid, root->sec_flavor, &rpc);
    if (status) {
        eprintf("nfs41_rpc_clnt_create() failed %d\n", status);
        goto out;
    }
 
    /* get a clientid with exchangeid */
    status = nfs41_exchange_id(rpc, &root->client_owner,
        nfs41_exchange_id_flags(is_data), &exchangeid);
    if (status) {
        eprintf("nfs41_exchange_id() failed %s\n", nfs_error_string(status));
        status = ERROR_BAD_NET_RESP;
        goto out_free_rpc;
    }
 
    /* attempt to match existing clients by the exchangeid response */
    EnterCriticalSection(&root->lock);
    status = root_client_find(root, &exchangeid, is_data, &client);
    LeaveCriticalSection(&root->lock);
 
    if (status == NO_ERROR)
        goto out_free_rpc;
 
    /* create a client for this clientid */
    status = root_client_create(root, rpc, is_data,
        lease_time, &exchangeid, &client);
    if (status) {
        eprintf("nfs41_client_create() failed %d\n", status);
        /* root_client_create takes care of cleaning up 
         * thus don't go to out_free_rpc */
        goto out;
    }
 
    /* because we don't hold the root's lock over session creation,
     * we could end up creating multiple clients with the same
     * server and roles */
    EnterCriticalSection(&root->lock);
    status = root_client_find(root, &exchangeid, is_data, &existing);
 
    if (status) {
        dprintf(NSLVL, "caching new client 0x%p\n", client);
 
        /* the client is not a duplicate, so add it to the list */
        list_add_tail(&root->clients, &client->root_entry);
        status = NO_ERROR;
    } else {
        dprintf(NSLVL, "created a duplicate client 0x%p! using "
            "existing client 0x%p instead\n", client, existing);
 
        /* a matching client has been created in parallel, so free
         * the one we created and use the existing client instead */
        nfs41_client_free(client);
        client = existing;
    }
    LeaveCriticalSection(&root->lock);
 
out:
    if (status == NO_ERROR)
        *client_out = client;
    dprintf(NSLVL, "<-- nfs41_root_mount_addrs() returning %d\n", status);
    return status;
 
out_free_rpc:
    nfs41_rpc_clnt_free(rpc);
    goto out;
}

Referenced by handle_mount(), pnfs_data_server_client(), and referral_mount_location().

nfs41_root_mount_referral()

int nfs41_root_mount_referral	(	IN nfs41_root *	root,
		IN const fs_locations4 *	locations,
		OUT const fs_location4 **	loc_out,
		OUT nfs41_client **	client_out
	)

Definition at line 459 of file namespace.c.

{
    int status = ERROR_BAD_NET_NAME;
    uint32_t i;
 
    /* establish a mount to the first available location */
    for (i = 0; i < locations->location_count; i++) {
        status = referral_mount_location(root,
            &locations->locations[i], client_out);
        if (status == NO_ERROR) {
            *loc_out = &locations->locations[i];
            break;
        }
    }
    return status;
}

Referenced by referral_resolve().

nfs41_root_mount_server()

int nfs41_root_mount_server	(	IN nfs41_root *	root,
		IN nfs41_server *	server,
		IN bool_t	is_data,
		IN OPTIONAL uint32_t	lease_time,
		OUT nfs41_client **	client_out
	)

nfs41_root_ref()

void nfs41_root_ref

(

IN nfs41_root *

root

)

Definition at line 92 of file namespace.c.

{
    const LONG count = InterlockedIncrement(&root->ref_count);
 
    dprintf(NSLVL, "nfs41_root_ref() count %d\n", count);
}

Referenced by handle_mount(), nfs41_delegation_recall(), and upcall_parse().

nfs41_root_session()

static __inline nfs41_session * nfs41_root_session ( IN nfs41_root *  root )

static

Definition at line 321 of file nfs41.h.

{
    nfs41_client *client;
    /* return a session for the server at the root of the namespace.
     * because we created it on mount, it's the first one in the list */
    EnterCriticalSection(&root->lock);
    client = list_container(root->clients.next, nfs41_client, root_entry);
    LeaveCriticalSection(&root->lock);
    return client->session;
}

Referenced by handle_open().

nfs41_rpc_clnt_create()

int nfs41_rpc_clnt_create	(	IN const multi_addr4 *	addrs,
		IN uint32_t	wsize,
		IN uint32_t	rsize,
		IN uint32_t	uid,
		IN uint32_t	gid,
		IN uint32_t	sec_flavor,
		OUT nfs41_rpc_clnt **	rpc_out
	)

Definition at line 145 of file nfs41_rpc.c.

{
    CLIENT *client;
    nfs41_rpc_clnt *rpc;
    uint32_t addr_index;
    int status;
    char machname[MAXHOSTNAMELEN + 1];
    gid_t gids[1];
    bool_t needcb = 1;
 
    rpc = calloc(1, sizeof(nfs41_rpc_clnt));
    if (rpc == NULL) {
        status = GetLastError();
        goto out;
    }
#ifdef NO_CB_4_KRB5P
    if (sec_flavor == RPCSEC_AUTHGSS_KRB5P)
        needcb = 0;
#endif
    rpc->needcb = needcb;
    rpc->cond = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (rpc->cond == NULL) {
        status = GetLastError();
        eprintf("CreateEvent failed %d\n", status);
        goto out_free_rpc_clnt;
    }
    status = get_client_for_multi_addr(addrs, wsize, rsize, needcb?rpc:NULL, 
                rpc->server_name, &client, &addr_index);
    if (status) {
        clnt_pcreateerror("connecting failed");
        goto out_free_rpc_cond;
    }
    if (send_null(client) != RPC_SUCCESS) {
        // XXX Do what here?
        eprintf("nfs41_rpc_clnt_create: send_null failed\n");
        status = ERROR_NETWORK_UNREACHABLE;
        goto out_err_client;
    }
 
    rpc->sec_flavor = sec_flavor;
    if (sec_flavor == RPCSEC_AUTH_SYS) {
        if (gethostname(machname, sizeof(machname)) == -1) {
            eprintf("nfs41_rpc_clnt_create: gethostname failed\n");
            goto out_err_client;
        }
        machname[sizeof(machname) - 1] = '\0';
        client->cl_auth = authsys_create(machname, uid, gid, 0, gids);
        if (client->cl_auth == NULL) {
            eprintf("nfs41_rpc_clnt_create: failed to create rpc authsys\n");
            status = ERROR_NETWORK_UNREACHABLE;
            goto out_err_client;
        }
    } else {
        status = create_rpcsec_auth_client(sec_flavor, rpc->server_name, client);
        if (status) {
            eprintf("nfs41_rpc_clnt_create: failed to establish security "
                    "context with %s\n", rpc->server_name);
            status = ERROR_NETWORK_UNREACHABLE;
            goto out_err_client;
        } else
            dprintf(1, "nfs41_rpc_clnt_create: successfully created %s\n", 
                secflavorop2name(sec_flavor));
    }
    rpc->rpc = client;
 
    /* keep a copy of the address and buffer sizes for reconnect */
    memcpy(&rpc->addrs, addrs, sizeof(multi_addr4));
    /* save the index of the address we connected to */
    rpc->addr_index = addr_index;
    rpc->wsize = wsize;
    rpc->rsize = rsize;
    rpc->is_valid_session = TRUE;
    rpc->uid = uid;
    rpc->gid = gid;
 
    //initialize rpc client lock
    InitializeSRWLock(&rpc->lock);
 
    *rpc_out = rpc;
out:
    return status;
out_err_client:
    clnt_destroy(client);
out_free_rpc_cond:
    CloseHandle(rpc->cond);
out_free_rpc_clnt:
    free(rpc);
    goto out;
}

Referenced by nfs41_root_mount_addrs().

nfs41_rpc_clnt_free()

void nfs41_rpc_clnt_free

(

IN nfs41_rpc_clnt *

rpc

)

Definition at line 243 of file nfs41_rpc.c.

{
    auth_destroy(rpc->rpc->cl_auth);
    clnt_destroy(rpc->rpc);
    CloseHandle(rpc->cond);
    free(rpc);
}

Referenced by nfs41_client_create(), nfs41_client_free(), and nfs41_root_mount_addrs().

nfs41_rpc_netaddr()

static __inline netaddr4 * nfs41_rpc_netaddr ( IN nfs41_rpc_clnt *  rpc )

static

Definition at line 500 of file nfs41.h.

{
    uint32_t id;
    AcquireSRWLockShared(&rpc->lock);
    /* only addr_index needs to be protected, as rpc->addrs is write-once */
    id = rpc->addr_index;
    ReleaseSRWLockShared(&rpc->lock);
 
    /* return the netaddr used to create the rpc client */
    return &rpc->addrs.arr[id];
}

Referenced by update_server().

nfs41_send_compound()

int nfs41_send_compound	(	IN nfs41_rpc_clnt *	rpc,
		IN char *	inbuf,
		OUT char *	outbuf
	)

Definition at line 337 of file nfs41_rpc.c.

{
    struct timeval timeout = {90, 100};
    enum clnt_stat rpc_status;
    int status, count = 0, one = 1, zero = 0;
    uint32_t version;
 
 try_again:
    AcquireSRWLockShared(&rpc->lock);
    version = rpc->version;
    rpc_status = clnt_call(rpc->rpc, 1,
                           (xdrproc_t)nfs_encode_compound, inbuf,
                           (xdrproc_t)nfs_decode_compound, outbuf,
                           timeout);
    ReleaseSRWLockShared(&rpc->lock);
 
    if (rpc_status != RPC_SUCCESS) {
        eprintf("clnt_call returned rpc_status = %s\n", 
            rpc_error_string(rpc_status));
        switch(rpc_status) {
        case RPC_CANTRECV:
        case RPC_CANTSEND:
        case RPC_TIMEDOUT:
        case RPC_AUTHERROR:
            if (++count > 3 || !rpc->is_valid_session) {
                status = ERROR_NETWORK_UNREACHABLE;
                break;
            }
            if (rpc_should_retry(rpc, version))
                goto try_again;
            while (rpc_renew_in_progress(rpc, NULL)) {
                status = WaitForSingleObject(rpc->cond, INFINITE);
                if (status != WAIT_OBJECT_0) {
                    dprintf(1, "rpc_renew_in_progress: WaitForSingleObject failed\n");
                    print_condwait_status(1, status);
                    status = ERROR_LOCK_VIOLATION;
                    goto out;
                }
                rpc_renew_in_progress(rpc, &zero);
                goto try_again;
            }
            rpc_renew_in_progress(rpc, &one);
            if (rpc_status == RPC_AUTHERROR && rpc->sec_flavor != RPCSEC_AUTH_SYS) {
                AcquireSRWLockExclusive(&rpc->lock);
                auth_destroy(rpc->rpc->cl_auth);
                status = create_rpcsec_auth_client(rpc->sec_flavor, 
                            rpc->server_name, rpc->rpc);
                ReleaseSRWLockExclusive(&rpc->lock);
                if (status) {
                    eprintf("Failed to reestablish security context\n");
                    status = ERROR_NETWORK_UNREACHABLE;
                    goto out;
                }
            } else
                if (rpc_reconnect(rpc))
                    eprintf("rpc_reconnect: Failed to reconnect!\n");
            rpc_renew_in_progress(rpc, &zero);
            goto try_again;
        default:
            eprintf("UNHANDLED RPC_ERROR: %d\n", rpc_status);
            status = ERROR_NETWORK_UNREACHABLE;
            goto out;
        }
        goto out;
    }
 
    status = 0;
out:
    return status;
}

Referenced by compound_encode_send_decode(), nfs41_bind_conn_to_session(), nfs41_destroy_clientid(), and nfs41_exchange_id().

nfs41_server_addrs()

void nfs41_server_addrs	(	IN nfs41_server *	server,
		OUT multi_addr4 *	addrs
	)

Definition at line 203 of file nfs41_server.c.

{
    struct server_addrs *saddrs = &server->addrs;
    uint32_t i, j;
 
    /* make a copy of the server's addrs, with most recent first */
    AcquireSRWLockShared(&saddrs->lock);
    j = saddrs->next_index;
    for (i = 0; i < saddrs->addrs.count; i++) {
        /* decrement/wrap j */
        j = (NFS41_ADDRS_PER_SERVER + j - 1) % NFS41_ADDRS_PER_SERVER;
        memcpy(&addrs->arr[i], &saddrs->addrs.arr[j], sizeof(netaddr4));
    }
    ReleaseSRWLockShared(&saddrs->lock);
}

nfs41_server_deref()

void nfs41_server_deref

(

IN nfs41_server *

server

)

Definition at line 155 of file nfs41_server.c.

{
    EnterCriticalSection(&g_server_list.lock);
 
    server->ref_count--;
    dprintf(SRVLVL, "nfs41_server_deref(%s) count %d\n",
        server->owner, server->ref_count);
    if (server->ref_count == 0) {
        list_remove(&server->entry);
        server_free(server);
    }
 
    LeaveCriticalSection(&g_server_list.lock);
}

Referenced by nfs41_client_free(), and update_server().

nfs41_server_find_or_create()

int nfs41_server_find_or_create	(	IN const char *	server_owner_major_id,
		IN const char *	server_scope,
		IN const netaddr4 *	addr,
		OUT nfs41_server **	server_out
	)

Definition at line 221 of file nfs41_server.c.

{
    struct server_info info;
    struct list_entry *entry;
    nfs41_server *server;
    int status;
 
    info.owner = server_owner_major_id;
    info.scope = server_scope;
 
    dprintf(SRVLVL, "--> nfs41_server_find_or_create(%s)\n", info.owner);
 
    EnterCriticalSection(&g_server_list.lock);
 
    /* search for an existing server */
    entry = list_search(&g_server_list.head, &info, server_compare);
    if (entry == NULL) {
        /* create a new server */
        status = server_create(&info, &server);
        if (status == NO_ERROR) {
            /* add it to the list */
            list_add_tail(&g_server_list.head, &server->entry);
            *server_out = server;
 
            dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
                "returning new server %p\n", server);
        } else {
            dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
                "returning %d\n", status);
        }
    } else {
        server = server_entry(entry);
        status = NO_ERROR;
 
        dprintf(SRVLVL, "<-- nfs41_server_find_or_create() "
            "returning existing server %p\n", server);
    }
 
    if (server) {
        /* register the address used to connect */
        server_addrs_add(&server->addrs, addr);
 
        server_ref_locked(server);
    }
 
    *server_out = server;
    LeaveCriticalSection(&g_server_list.lock);
    return status;
}

Referenced by update_server().

nfs41_server_list_init()

void nfs41_server_list_init

(

)

Definition at line 48 of file nfs41_server.c.

{
    list_init(&g_server_list.head);
    InitializeCriticalSection(&g_server_list.lock);
}

Referenced by ServiceStart().

nfs41_server_ref()

void nfs41_server_ref

(

IN nfs41_server *

server

)

Definition at line 145 of file nfs41_server.c.

{
    EnterCriticalSection(&g_server_list.lock);
 
    server_ref_locked(server);
 
    LeaveCriticalSection(&g_server_list.lock);
}

nfs41_server_resolve()

int nfs41_server_resolve	(	IN const char *	hostname,
		IN unsigned short	port,
		OUT multi_addr4 *	addrs
	)

Definition at line 275 of file nfs41_server.c.

{
    int status = ERROR_BAD_NET_NAME;
    char service[16];
    struct addrinfo hints = { 0 }, *res, *info;
    struct netconfig *nconf;
    struct netbuf addr;
    char *netid, *uaddr;
 
    dprintf(SRVLVL, "--> nfs41_server_resolve(%s:%u)\n",
        hostname, port);
 
    addrs->count = 0;
 
    StringCchPrintfA(service, 16, "%u", port);
 
    /* request a list of tcp addrs for the given hostname,port */
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
 
    if (getaddrinfo(hostname, service, &hints, &res) != 0)
        goto out;
 
    for (info = res; info != NULL; info = info->ai_next) {
        /* find the appropriate entry in /etc/netconfig */
        switch (info->ai_family) {
        case AF_INET:  netid = "tcp";  break;
        case AF_INET6: netid = "tcp6"; break;
        default: continue;
        }
 
        nconf = getnetconfigent(netid);
        if (nconf == NULL)
            continue;
 
        /* convert to a transport-independent universal address */
        addr.buf = info->ai_addr;
        addr.maxlen = addr.len = (unsigned int)info->ai_addrlen;
 
        uaddr = taddr2uaddr(nconf, &addr);
        freenetconfigent(nconf);
 
        if (uaddr == NULL)
            continue;
 
        StringCchCopyA(addrs->arr[addrs->count].netid,
            NFS41_NETWORK_ID_LEN+1, netid);
        StringCchCopyA(addrs->arr[addrs->count].uaddr,
            NFS41_UNIVERSAL_ADDR_LEN+1, uaddr);
        freeuaddr(uaddr);
 
        status = NO_ERROR;
        if (++addrs->count >= NFS41_ADDRS_PER_SERVER)
            break;
    }
    freeaddrinfo(res);
out:
    if (status)
        dprintf(SRVLVL, "<-- nfs41_server_resolve(%s:%u) returning "
            "error %d\n", hostname, port, status);
    else
        dprintf(SRVLVL, "<-- nfs41_server_resolve(%s:%u) returning "
            "%s\n", hostname, port, addrs->arr[0].uaddr);
    return status;
}

Referenced by handle_mount(), and referral_mount_location().

nfs41_session_bad_slot()

int nfs41_session_bad_slot	(	IN nfs41_session *	session,
		IN OUT struct __nfs41_sequence_args *	args
	)

Referenced by compound_encode_send_decode().

nfs41_session_bump_seq()

void nfs41_session_bump_seq	(	IN nfs41_session *	session,
		IN uint32_t	slotid,
		IN uint32_t	target_highest_slotid
	)

Definition at line 80 of file nfs41_session.c.

{
    nfs41_slot_table *table = &session->table;
 
    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);
 
    if (slotid < NFS41_MAX_NUM_SLOTS)
        table->seq_nums[slotid]++;
 
    /* adjust max_slots in response to changes in target_highest_slotid,
     * but not immediately after a CB_RECALL_SLOT or NFS4ERR_BADSLOT error */
    if (table->target_delay <= GetTickCount64())
        resize_slot_table(table, target_highest_slotid);
 
    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);
}

Referenced by compound_encode_send_decode().

nfs41_session_create()

int nfs41_session_create	(	IN nfs41_client *	client,
		IN nfs41_session **	session_out
	)

Definition at line 278 of file nfs41_session.c.

{
    nfs41_session *session;
    int status;
 
    status = session_alloc(client, &session);
    if (status) {
        eprintf("session_alloc() failed with %d\n", status);
        goto out;
    }
 
    AcquireSRWLockShared(&client->exid_lock);
    if (client->rpc->needcb)
        session->flags |= CREATE_SESSION4_FLAG_CONN_BACK_CHAN;
    session->flags |= CREATE_SESSION4_FLAG_PERSIST;
    ReleaseSRWLockShared(&client->exid_lock);
 
    status = nfs41_create_session(client, session, TRUE);
    if (status) {
        eprintf("nfs41_create_session failed %d\n", status);
        status = ERROR_BAD_NET_RESP;
        goto out_err;
    }
 
    AcquireSRWLockExclusive(&session->client->session_lock);
    client->session = session;
    session->isValidState = TRUE;
    ReleaseSRWLockExclusive(&session->client->session_lock);
    *session_out = session;
out:
    return status;
 
out_err:
    nfs41_session_free(session);
    goto out;
}

Referenced by root_client_create().

nfs41_session_free()

void nfs41_session_free

(

IN nfs41_session *

session

)

Definition at line 363 of file nfs41_session.c.

{
    AcquireSRWLockExclusive(&session->client->session_lock);
    if (valid_handle(session->renew_thread)) {
        dprintf(1, "nfs41_session_free: terminating session renewal thread\n");
        if (!TerminateThread(session->renew_thread, NO_ERROR))
            eprintf("failed to terminate renewal thread %p\n",
                session->renew_thread);
    }
 
    if (session->isValidState) {
        session->client->rpc->is_valid_session = FALSE;
        nfs41_destroy_session(session);
    }
    DeleteCriticalSection(&session->table.lock);
    ReleaseSRWLockExclusive(&session->client->session_lock);
    free(session);
}

Referenced by nfs41_client_free(), and nfs41_session_create().

nfs41_session_free_slot()

void nfs41_session_free_slot	(	IN nfs41_session *	session,
		IN uint32_t	slotid
	)

Definition at line 102 of file nfs41_session.c.

{
    nfs41_slot_table *table = &session->table;
 
    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);
 
    /* flag the slot as unused */
    if (slotid < NFS41_MAX_NUM_SLOTS && table->used_slots[slotid]) {
        table->used_slots[slotid] = 0;
        table->num_used--;
    }
    /* update highest_used if necessary */
    if (slotid == table->highest_used) {
        while (table->highest_used && !table->used_slots[table->highest_used])
            table->highest_used--;
    }
    dprintf(3, "freeing slot#=%d used=%d highest=%d\n",
        slotid, table->num_used, table->highest_used);
 
    /* wake any threads waiting on a slot */
    if (slot_table_avail(table))
        WakeAllConditionVariable(&table->cond);
 
    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);
}

Referenced by compound_encode_send_decode(), and nfs41_session_bad_slot().

nfs41_session_get_slot()

void nfs41_session_get_slot	(	IN nfs41_session *	session,
		OUT uint32_t *	slot,
		OUT uint32_t *	seq,
		OUT uint32_t *	highest
	)

Definition at line 132 of file nfs41_session.c.

{
    nfs41_slot_table *table = &session->table;
    uint32_t i;
 
    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);
 
    /* wait for an available slot */
    while (!slot_table_avail(table))
        SleepConditionVariableCS(&table->cond, &table->lock, INFINITE);
 
    for (i = 0; i < table->max_slots; i++) {
        if (table->used_slots[i])
            continue;
 
        table->used_slots[i] = 1;
        table->num_used++;
        if (i > table->highest_used)
            table->highest_used = i;
 
        *slot = i;
        *seqid = table->seq_nums[i];
        *highest = table->highest_used;
        break;
    }
    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);
 
    dprintf(2, "session %p: using slot#=%d with seq#=%d highest=%d\n",
        session, *slot, *seqid, *highest);
}

Referenced by compound_encode_send_decode(), nfs41_session_bad_slot(), and nfs41_session_sequence().

nfs41_session_recall_slot()

int nfs41_session_recall_slot	(	IN nfs41_session *	session,
		IN OUT uint32_t	target_highest_slotid
	)

Definition at line 169 of file nfs41_session.c.

{
    nfs41_slot_table *table = &session->table;
 
    AcquireSRWLockShared(&session->client->session_lock);
    EnterCriticalSection(&table->lock);
    resize_slot_table(table, target_highest_slotid);
    table->target_delay = GetTickCount64() + MAX_SLOTS_DELAY;
    LeaveCriticalSection(&table->lock);
    ReleaseSRWLockShared(&session->client->session_lock);
 
    return NFS4_OK;
}

Referenced by handle_cb_recall_slot().

nfs41_session_renew()

int nfs41_session_renew

(

IN nfs41_session *

session

)

Definition at line 318 of file nfs41_session.c.

{
    int status;
 
    AcquireSRWLockExclusive(&session->client->session_lock);
    session->cb_session.cb_seqnum = 0;
    init_slot_table(&session->table);
 
    status = nfs41_create_session(session->client, session, FALSE);
    ReleaseSRWLockExclusive(&session->client->session_lock);
    return status;
}

Referenced by nfs41_recover_session().

nfs41_session_sequence()

void nfs41_session_sequence	(	struct __nfs41_sequence_args *	args,
		nfs41_session *	session,
		bool_t	cachethis
	)

Definition at line 214 of file nfs41_session.c.

{
    nfs41_session_get_slot(session, &args->sa_slotid, 
        &args->sa_sequenceid, &args->sa_highest_slotid);
    args->sa_sessionid = session->session_id;
    args->sa_cachethis = cachethis;
}

Referenced by lookup_rpc(), nfs41_access(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_delegpurge(), nfs41_delegreturn(), nfs41_free_stateid(), nfs41_fs_locations(), nfs41_getattr(), nfs41_link(), nfs41_lock(), nfs41_open(), nfs41_read(), nfs41_readdir(), nfs41_readlink(), nfs41_reclaim_complete(), nfs41_remove(), nfs41_rename(), nfs41_rpc_openattr(), nfs41_secinfo(), nfs41_secinfo_noname(), nfs41_send_sequence(), nfs41_setattr(), nfs41_superblock_getattr(), nfs41_test_stateid(), nfs41_unlock(), nfs41_want_delegation(), nfs41_write(), pnfs_rpc_getdeviceinfo(), pnfs_rpc_layoutcommit(), pnfs_rpc_layoutget(), pnfs_rpc_layoutreturn(), and rpc_array_putfh().

nfs41_session_set_lease()

int nfs41_session_set_lease	(	IN nfs41_session *	session,
		IN uint32_t	lease_time
	)

Definition at line 332 of file nfs41_session.c.

{
    int status = NO_ERROR;
    uint32_t thread_id;
 
    if (valid_handle(session->renew_thread)) {
        eprintf("nfs41_session_set_lease(): session "
            "renewal thread already started!\n");
        goto out;
    }
 
    if (lease_time == 0) {
        eprintf("nfs41_session_set_lease(): invalid lease_time=0\n");
        status = ERROR_INVALID_PARAMETER;
        goto out;
    }
 
    session->lease_time = lease_time;
    session->renew_thread = (HANDLE)_beginthreadex(NULL,
        0, renew_session, session, 0, &thread_id);
    if (!valid_handle(session->renew_thread)) {
        status = GetLastError();
        eprintf("_beginthreadex failed %d\n", status);
        goto out;
    }
out:
    return status;
}

Referenced by session_get_lease().

nfs41_superblock_for_fh()

int nfs41_superblock_for_fh	(	IN nfs41_session *	session,
		IN const nfs41_fsid *	fsid,
		IN const nfs41_fh *parent	OPTIONAL,
		OUT nfs41_path_fh *	file
	)

Definition at line 233 of file nfs41_superblock.c.

{
    int status = NFS4_OK;
    nfs41_server *server = client_server(session->client);
    nfs41_superblock_list *superblocks = &server->superblocks;
    nfs41_superblock *superblock;
 
    dprintf(SBLVL, "--> nfs41_superblock_for_fh(fsid(%llu,%llu))\n",
        fsid->major, fsid->minor);
 
    /* compare with the parent's fsid, and use that if it matches */
    if (parent && parent->superblock &&
            compare_fsid(fsid, &parent->superblock->fsid) == 0) {
        file->fh.superblock = parent->superblock;
        dprintf(SBLVL, "using superblock from parent\n");
        goto out;
    }
 
    /* using a shared lock, search for an existing superblock */
    AcquireSRWLockShared(&superblocks->lock);
    superblock = find_superblock(superblocks, fsid);
    ReleaseSRWLockShared(&superblocks->lock);
 
    if (superblock) {
        dprintf(SBLVL, "found existing superblock in server list "
            "[shared lock]\n");
    } else {
        AcquireSRWLockExclusive(&superblocks->lock);
        /* must search again under an exclusive lock, in case another thread
         * created it after our first search */
        superblock = find_superblock(superblocks, fsid);
        if (superblock) {
            dprintf(SBLVL, "found newly created superblock in server list "
                "[exclusive lock]\n");
        } else {
            /* create the superblock */
            status = superblock_create(fsid, &superblock);
            if (status == NO_ERROR) /* add it to the list */
                list_add_tail(&superblocks->head, &superblock->entry);
        }
        ReleaseSRWLockExclusive(&superblocks->lock);
    }
 
    if (status == NO_ERROR && superblock->supported_attrs.count == 0) {
        /* exclusive lock on the superblock while fetching attributes */
        AcquireSRWLockExclusive(&superblock->lock);
        if (superblock->supported_attrs.count == 0)
            status = get_superblock_attrs(session, superblock, file);
        ReleaseSRWLockExclusive(&superblock->lock);
    }
 
    file->fh.superblock = superblock;
out:
    dprintf(SBLVL, "<-- nfs41_superblock_for_fh() returning %p, status %d\n",
        file->fh.superblock, status);
    return status;
}

Referenced by nfs41_link(), nfs41_open(), and server_lookup().

nfs41_superblock_fs_attributes()

void nfs41_superblock_fs_attributes	(	IN const nfs41_superblock *	superblock,
		OUT struct _FILE_FS_ATTRIBUTE_INFORMATION *	FsAttrs
	)

Referenced by handle_mount(), and handle_volume().

nfs41_superblock_getattr_mask()

static __inline void nfs41_superblock_getattr_mask ( IN const nfs41_superblock *  superblock, OUT bitmap4 *  attrs  )

static

Definition at line 448 of file nfs41.h.

{
    memcpy(attrs, &superblock->default_getattr, sizeof(bitmap4));
}

Referenced by handle_readdir(), nfs41_cached_getattr(), nfs41_close(), nfs41_commit(), nfs41_create(), nfs41_link(), nfs41_open(), nfs41_remove(), nfs41_rename(), nfs41_setattr(), nfs41_write(), pnfs_rpc_layoutcommit(), pnfs_write(), and write_to_mds().

nfs41_superblock_list_free()

void nfs41_superblock_list_free

(

IN nfs41_superblock_list *

superblocks

)

Definition at line 221 of file nfs41_superblock.c.

{
    struct list_entry *entry, *tmp;
 
    dprintf(SBLVL, "nfs41_superblock_list_free()\n");
 
    list_for_each_tmp(entry, tmp, &superblocks->head)
        free(superblock_entry(entry));
}

Referenced by server_free().

nfs41_superblock_list_init()

void nfs41_superblock_list_init

(

IN nfs41_superblock_list *

superblocks

)

Definition at line 214 of file nfs41_superblock.c.

{
    list_init(&superblocks->head);
    InitializeSRWLock(&superblocks->lock);
}

Referenced by server_create().

nfs41_superblock_space_changed()

void nfs41_superblock_space_changed

(

IN nfs41_superblock *

superblock

)

Definition at line 295 of file nfs41_superblock.c.

{
    /* invalidate cached volume size attributes */
    AcquireSRWLockExclusive(&superblock->lock);
    superblock->cache_expiration = 0;
    ReleaseSRWLockExclusive(&superblock->lock);
}

Referenced by nfs41_commit(), nfs41_create(), nfs41_link(), nfs41_open(), nfs41_remove(), nfs41_setattr(), and nfs41_write().

nfs41_superblock_supported_attrs()

static __inline void nfs41_superblock_supported_attrs ( IN const nfs41_superblock *  superblock, IN OUT bitmap4 *  attrs  )

static

Definition at line 454 of file nfs41.h.

{
    bitmap_intersect(attrs, &superblock->supported_attrs);
}

Referenced by delegation_truncate(), get_superblock_attrs(), nfs41_create(), and nfs41_open().

nfs41_superblock_supported_attrs_exclcreat()

static __inline void nfs41_superblock_supported_attrs_exclcreat ( IN const nfs41_superblock *  superblock, IN OUT bitmap4 *  attrs  )

static

Definition at line 460 of file nfs41.h.

{
    bitmap_intersect(attrs, &superblock->suppattr_exclcreat);
}

Referenced by nfs41_open().