namespace.c File Reference

#include <windows.h>
#include <strsafe.h>
#include "nfs41_ops.h"
#include "util.h"
#include "daemon_debug.h"

Include dependency graph for namespace.c:

Go to the source code of this file.

Classes
struct	cl_addr_info
struct	cl_exid_info

Macros
#define	NSLVL   2 /* dprintf level for namespace logging */
#define	client_entry(pos)   list_container(pos, nfs41_client, root_entry)

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)
static void	root_free (IN nfs41_root *root)
void	nfs41_root_ref (IN nfs41_root *root)
void	nfs41_root_deref (IN nfs41_root *root)
static int	cl_addr_compare (IN const struct list_entry *entry, IN const void *value)
static int	root_client_find_addrs (IN nfs41_root *root, IN const multi_addr4 *addrs, IN bool_t is_data, OUT nfs41_client **client_out)
static int	cl_exid_compare (IN const struct list_entry *entry, IN const void *value)
static int	root_client_find (IN nfs41_root *root, IN const nfs41_exchange_id_res *exchangeid, IN bool_t is_data, OUT nfs41_client **client_out)
static int	session_get_lease (IN nfs41_session *session, IN OPTIONAL uint32_t lease_time)
static int	root_client_create (IN nfs41_root *root, IN nfs41_rpc_clnt *rpc, IN bool_t is_data, IN OPTIONAL uint32_t lease_time, IN const nfs41_exchange_id_res *exchangeid, OUT nfs41_client **client_out)
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)
static int	referral_mount_location (IN nfs41_root *root, IN const fs_location4 *loc, 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)

Macro Definition Documentation

client_entry

#define client_entry

(

pos

)

list_container(pos, nfs41_client, root_entry)

Definition at line 33 of file namespace.c.

NSLVL

#define NSLVL   2 /* dprintf level for namespace logging */

Definition at line 30 of file namespace.c.

Function Documentation

cl_addr_compare()

static int cl_addr_compare ( IN const struct list_entry *  entry, IN const void *  value  )

static

Definition at line 117 of file namespace.c.

{
    nfs41_client *client = client_entry(entry);
    const struct cl_addr_info *info = (const struct cl_addr_info*)value;
    uint32_t i, roles;
 
    /* match any of the desired roles */
    AcquireSRWLockShared(&client->exid_lock);
    roles = info->roles & client->roles;
    ReleaseSRWLockShared(&client->exid_lock);
 
    if (roles == 0)
        return ERROR_FILE_NOT_FOUND;
 
    /* match any address in 'addrs' with any address in client->rpc->addrs */
    for (i = 0; i < info->addrs->count; i++)
        if (multi_addr_find(&client->rpc->addrs, &info->addrs->arr[i], NULL))
            return NO_ERROR;
 
    return ERROR_FILE_NOT_FOUND;
}

Referenced by root_client_find_addrs().

cl_exid_compare()

static int cl_exid_compare ( IN const struct list_entry *  entry, IN const void *  value  )

static

Definition at line 176 of file namespace.c.

{
    nfs41_client *client = client_entry(entry);
    const struct cl_exid_info *info = (const struct cl_exid_info*)value;
    int status = ERROR_FILE_NOT_FOUND;
 
    AcquireSRWLockShared(&client->exid_lock);
 
    /* match any of the desired roles */
    if ((info->roles & client->roles) == 0)
        goto out;
    /* match server_owner.major_id */
    if (strncmp(info->exchangeid->server_owner.so_major_id,
        client->server->owner, NFS4_OPAQUE_LIMIT) != 0)
        goto out;
    /* match server_scope */
    if (strncmp(info->exchangeid->server_scope,
        client->server->scope, NFS4_OPAQUE_LIMIT) != 0)
        goto out;
    /* match clientid */
    if (info->exchangeid->clientid != client->clnt_id)
        goto out;
 
    status = NO_ERROR;
out:
    ReleaseSRWLockShared(&client->exid_lock);
    return status;
}

Referenced by root_client_find().

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_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().

referral_mount_location()

static int referral_mount_location ( IN nfs41_root *  root, IN const fs_location4 *  loc, OUT nfs41_client **  client_out  )

static

Definition at line 437 of file namespace.c.

{
    multi_addr4 addrs;
    int status = ERROR_BAD_NET_NAME;
    uint32_t i;
 
    /* create a client and session for the first available server */
    for (i = 0; i < loc->server_count; i++) {
        /* XXX: only deals with 'address' as a hostname with default port */
        status = nfs41_server_resolve(loc->servers[i].address, 2049, &addrs);
        if (status) continue;
 
        status = nfs41_root_mount_addrs(root, &addrs, 0, 0, client_out);
        if (status == NO_ERROR)
            break;
    }
    return status;
}

Referenced by nfs41_root_mount_referral().

root_client_create()

static int root_client_create ( IN nfs41_root *  root, IN nfs41_rpc_clnt *  rpc, IN bool_t  is_data, IN OPTIONAL uint32_t  lease_time, IN const nfs41_exchange_id_res *  exchangeid, OUT nfs41_client **  client_out  )

static

Definition at line 281 of file namespace.c.

{
    nfs41_client *client;
    nfs41_session *session;
    int status;
 
    /* create client (transfers ownership of rpc to client) */
    status = nfs41_client_create(rpc, &root->client_owner,
        is_data, exchangeid, &client);
    if (status) {
        eprintf("nfs41_client_create() failed with %d\n", status);
        goto out;
    }
    client->root = root;
    rpc->client = client;
 
    /* create session (and client takes ownership) */
    status = nfs41_session_create(client, &session);
    if (status) {
        eprintf("nfs41_session_create failed %d\n", status);
        goto out_err;
    }
 
    if (!is_data) {
        /* send RECLAIM_COMPLETE, but don't fail on ERR_NOTSUPP */
        status = nfs41_reclaim_complete(session);
        if (status && status != NFS4ERR_NOTSUPP) {
            eprintf("nfs41_reclaim_complete() failed with %s\n",
                nfs_error_string(status));
            status = ERROR_BAD_NETPATH;
            goto out_err;
        }
    }
 
    /* get least time and start session renewal thread */
    status = session_get_lease(session, lease_time);
    if (status)
        goto out_err;
 
    *client_out = client;
out:
    return status;
 
out_err:
    nfs41_client_free(client);
    goto out;
}

Referenced by nfs41_root_mount_addrs().

root_client_find()

static int root_client_find ( IN nfs41_root *  root, IN const nfs41_exchange_id_res *  exchangeid, IN bool_t  is_data, OUT nfs41_client **  client_out  )

static

Definition at line 207 of file namespace.c.

{
    struct cl_exid_info info;
    struct list_entry *entry;
    int status;
 
    dprintf(NSLVL, "--> root_client_find()\n");
 
    info.exchangeid = exchangeid;
    info.roles = nfs41_exchange_id_flags(is_data) & EXCHGID4_FLAG_MASK_PNFS;
 
    entry = list_search(&root->clients, &info, cl_exid_compare);
    if (entry) {
        *client_out = client_entry(entry);
        status = NO_ERROR;
        dprintf(NSLVL, "<-- root_client_find() returning 0x%p\n",
            *client_out);
    } else {
        status = ERROR_FILE_NOT_FOUND;
        dprintf(NSLVL, "<-- root_client_find() failed with %d\n",
            status);
    }
    return status;
}

Referenced by nfs41_root_mount_addrs().

root_client_find_addrs()

static int root_client_find_addrs ( IN nfs41_root *  root, IN const multi_addr4 *  addrs, IN bool_t  is_data, OUT nfs41_client **  client_out  )

static

Definition at line 141 of file namespace.c.

{
    struct cl_addr_info info;
    struct list_entry *entry;
    int status;
 
    dprintf(NSLVL, "--> root_client_find_addrs()\n");
 
    info.addrs = addrs;
    info.roles = nfs41_exchange_id_flags(is_data) & EXCHGID4_FLAG_MASK_PNFS;
 
    entry = list_search(&root->clients, &info, cl_addr_compare);
    if (entry) {
        *client_out = client_entry(entry);
        status = NO_ERROR;
        dprintf(NSLVL, "<-- root_client_find_addrs() returning 0x%p\n",
            *client_out);
    } else {
        status = ERROR_FILE_NOT_FOUND;
        dprintf(NSLVL, "<-- root_client_find_addrs() failed with %d\n",
            status);
    }
    return status;
}

Referenced by nfs41_root_mount_addrs().

root_free()

static void root_free ( IN nfs41_root *  root )

static

Definition at line 76 of file namespace.c.

{
    struct list_entry *entry, *tmp;
 
    dprintf(NSLVL, "--> nfs41_root_free()\n");
 
    /* free clients */
    list_for_each_tmp(entry, tmp, &root->clients)
        nfs41_client_free(client_entry(entry));
    DeleteCriticalSection(&root->lock);
    free(root);
 
    dprintf(NSLVL, "<-- nfs41_root_free()\n");
}

Referenced by nfs41_root_deref().

session_get_lease()

static int session_get_lease ( IN nfs41_session *  session, IN OPTIONAL uint32_t  lease_time  )

static

Definition at line 236 of file namespace.c.

{
    bool_t use_mds_lease;
    int status;
 
    /* http://tools.ietf.org/html/rfc5661#section-13.1.1
     * 13.1.1. Sessions Considerations for Data Servers:
     * If the reply to EXCHANGE_ID has just the EXCHGID4_FLAG_USE_PNFS_DS role
     * set, then (as noted in Section 13.6) the client will not be able to
     * determine the data server's lease_time attribute because GETATTR will
     * not be permitted.  Instead, the rule is that any time a client
     * receives a layout referring it to a data server that returns just the
     * EXCHGID4_FLAG_USE_PNFS_DS role, the client MAY assume that the
     * lease_time attribute from the metadata server that returned the
     * layout applies to the data server. */
    AcquireSRWLockShared(&session->client->exid_lock);
    use_mds_lease = session->client->roles == EXCHGID4_FLAG_USE_PNFS_DS;
    ReleaseSRWLockShared(&session->client->exid_lock);
 
    if (!use_mds_lease) {
        /* the client is allowed to GETATTR, so query the lease_time */
        nfs41_file_info info = { 0 };
        bitmap4 attr_request = { 1, { FATTR4_WORD0_LEASE_TIME, 0, 0 } };
 
        status = nfs41_getattr(session, NULL, &attr_request, &info);
        if (status) {
            eprintf("nfs41_getattr() failed with %s\n",
                nfs_error_string(status));
            status = nfs_to_windows_error(status, ERROR_BAD_NET_RESP);
            goto out;
        }
        lease_time = info.lease_time;
    }
 
    status = nfs41_session_set_lease(session, lease_time);
    if (status) {
        eprintf("nfs41_session_set_lease() failed %d\n", status);
        goto out;
    }
out:
    return status;
}

Referenced by root_client_create().