pnfs_device.c File Reference

#include <windows.h>
#include <strsafe.h>
#include <stdio.h>
#include "nfs41_ops.h"
#include "nfs41_callback.h"
#include "daemon_debug.h"

Include dependency graph for pnfs_device.c:

Go to the source code of this file.

Classes
struct	pnfs_file_device_list

Macros
#define	FDLVL   2 /* dprintf level for file device logging */
#define	device_entry(pos)   list_container(pos, pnfs_file_device, entry)

Functions
static enum pnfs_status	file_device_create (IN const unsigned char *deviceid, IN struct pnfs_file_device_list *devices, OUT pnfs_file_device **device_out)
static void	file_device_free (IN pnfs_file_device *device)
static int	deviceid_compare (const struct list_entry *entry, const void *deviceid)
static enum pnfs_status	file_device_find_or_create (IN const unsigned char *deviceid, IN struct pnfs_file_device_list *devices, OUT pnfs_file_device **device_out)
enum pnfs_status	pnfs_file_device_list_create (OUT struct pnfs_file_device_list **devices_out)
void	pnfs_file_device_list_free (IN struct pnfs_file_device_list *devices)
void	pnfs_file_device_list_invalidate (IN struct pnfs_file_device_list *devices)
enum pnfs_status	pnfs_file_device_get (IN nfs41_session *session, IN struct pnfs_file_device_list *devices, IN unsigned char *deviceid, OUT pnfs_file_device **device_out)
void	pnfs_file_device_put (IN pnfs_file_device *device)
static enum pnfs_status	data_client_status (IN pnfs_data_server *server, OUT nfs41_client **client_out)
enum pnfs_status	pnfs_data_server_client (IN nfs41_root *root, IN pnfs_data_server *server, IN uint32_t default_lease, OUT nfs41_client **client_out)
enum pnfs_status	pnfs_file_device_notify (IN struct pnfs_file_device_list *devices, IN const struct notify_deviceid4 *change)

Macro Definition Documentation

device_entry

#define device_entry

(

pos

)

list_container(pos, pnfs_file_device, entry)

Definition at line 40 of file pnfs_device.c.

FDLVL

#define FDLVL   2 /* dprintf level for file device logging */

Definition at line 31 of file pnfs_device.c.

Function Documentation

data_client_status()

static enum pnfs_status data_client_status ( IN pnfs_data_server *  server, OUT nfs41_client **  client_out  )

static

Definition at line 268 of file pnfs_device.c.

{
    enum pnfs_status status = PNFSERR_NOT_CONNECTED;

    if (server->client) {
        dprintf(FDLVL, "pnfs_data_server_client() returning "
            "existing client %llu\n", server->client->clnt_id);
        *client_out = server->client;
        status = PNFS_SUCCESS;
    }
    return status;
}

Referenced by pnfs_data_server_client().

deviceid_compare()

static int deviceid_compare ( const struct list_entry *  entry, const void *  deviceid  )

static

Definition at line 74 of file pnfs_device.c.

{
    const pnfs_file_device *device = device_entry(entry);
    return memcmp(device->device.deviceid, deviceid, PNFS_DEVICEID_SIZE);
}

Referenced by file_device_find_or_create(), and pnfs_file_device_notify().

file_device_create()

static enum pnfs_status file_device_create ( IN const unsigned char *  deviceid, IN struct pnfs_file_device_list *  devices, OUT pnfs_file_device **  device_out  )

static

Definition at line 43 of file pnfs_device.c.

{
    enum pnfs_status status = PNFS_SUCCESS;
    pnfs_file_device *device;

    device = calloc(1, sizeof(pnfs_file_device));
    if (device == NULL) {
        status = PNFSERR_RESOURCES;
        goto out;
    }

    memcpy(device->device.deviceid, deviceid, PNFS_DEVICEID_SIZE);
    device->devices = devices;
    InitializeCriticalSection(&device->device.lock);
    *device_out = device;
out:
    return status;
}

Referenced by file_device_find_or_create().

file_device_find_or_create()

static enum pnfs_status file_device_find_or_create ( IN const unsigned char *  deviceid, IN struct pnfs_file_device_list *  devices, OUT pnfs_file_device **  device_out  )

static

Definition at line 82 of file pnfs_device.c.

{
    struct list_entry *entry;
    enum pnfs_status status;

    dprintf(FDLVL, "--> pnfs_file_device_find_or_create()\n");

    EnterCriticalSection(&devices->lock);

    /* search for an existing device */
    entry = list_search(&devices->head, deviceid, deviceid_compare);
    if (entry == NULL) {
        /* create a new device */
        pnfs_file_device *device;
        status = file_device_create(deviceid, devices, &device);
        if (status == PNFS_SUCCESS) {
            /* add it to the list */
            list_add_tail(&devices->head, &device->entry);
            *device_out = device;

            dprintf(FDLVL, "<-- pnfs_file_device_find_or_create() "
                "returning new device %p\n", device);
        } else {
            dprintf(FDLVL, "<-- pnfs_file_device_find_or_create() "
                "returning %s\n", pnfs_error_string(status));
        }
    } else {
        *device_out = device_entry(entry);
        status = PNFS_SUCCESS;

        dprintf(FDLVL, "<-- pnfs_file_device_find_or_create() "
            "returning existing device %p\n", *device_out);
    }

    LeaveCriticalSection(&devices->lock);
    return status;
}

Referenced by pnfs_file_device_get().

file_device_free()

static void file_device_free ( IN pnfs_file_device *  device )

static

Definition at line 65 of file pnfs_device.c.

{
    free(device->servers.arr);
    free(device->stripes.arr);
    DeleteCriticalSection(&device->device.lock);
    free(device);
}

Referenced by pnfs_file_device_list_free(), pnfs_file_device_list_invalidate(), and pnfs_file_device_put().

pnfs_data_server_client()

enum pnfs_status pnfs_data_server_client	(	IN nfs41_root *	root,
		IN pnfs_data_server *	server,
		IN uint32_t	default_lease,
		OUT nfs41_client **	client_out
	)

Definition at line 283 of file pnfs_device.c.

{
    int status;
    enum pnfs_status pnfsstat;

    dprintf(FDLVL, "--> pnfs_data_server_client('%s')\n",
        server->addrs.arr[0].uaddr);

    /* if we've already created the client, return it */
    AcquireSRWLockShared(&server->lock);
    pnfsstat = data_client_status(server, client_out);
    ReleaseSRWLockShared(&server->lock);

    if (!pnfsstat)
        goto out;

    AcquireSRWLockExclusive(&server->lock);

    pnfsstat = data_client_status(server, client_out);
    if (pnfsstat) {
        status = nfs41_root_mount_addrs(root, &server->addrs, 1, default_lease, 
            &server->client);
        if (status) {
            dprintf(FDLVL, "data_client_create('%s') failed with %d\n",
                server->addrs.arr[0].uaddr, status);
        } else {
            *client_out = server->client;
            pnfsstat = PNFS_SUCCESS;

            dprintf(FDLVL, "pnfs_data_server_client() returning new client "
                "%llu\n", server->client->clnt_id);
        }
    }

    ReleaseSRWLockExclusive(&server->lock);
out:
    return pnfsstat;
}

pnfs_file_device_get()

enum pnfs_status pnfs_file_device_get	(	IN nfs41_session *	session,
		IN struct pnfs_file_device_list *	devices,
		IN unsigned char *	deviceid,
		OUT pnfs_file_device **	device_out
	)

Definition at line 192 of file pnfs_device.c.

{
    pnfs_file_device *device;
    enum pnfs_status status;
    enum nfsstat4 nfsstat;

    dprintf(FDLVL, "--> pnfs_file_device_get()\n");

    status = file_device_find_or_create(deviceid, devices, &device);
    if (status)
        goto out;

    EnterCriticalSection(&device->device.lock);

    /* don't give out a device that's been revoked */
    if (device->device.status & PNFS_DEVICE_REVOKED)
        status = PNFSERR_NO_DEVICE;
    else if (device->device.status & PNFS_DEVICE_GRANTED)
        status = PNFS_SUCCESS;
    else {
        nfsstat = pnfs_rpc_getdeviceinfo(session, deviceid, device);
        if (nfsstat == NFS4_OK) {
            device->device.status = PNFS_DEVICE_GRANTED;
            status = PNFS_SUCCESS;

            dprintf(FDLVL, "Received device info:\n");
            dprint_device(FDLVL, device);
        } else {
            status = PNFSERR_NO_DEVICE;

            eprintf("pnfs_rpc_getdeviceinfo() failed with %s\n",
                nfs_error_string(nfsstat));
        }
    }

    if (status == PNFS_SUCCESS) {
        device->device.layout_count++;
        dprintf(FDLVL, "pnfs_file_device_get() -> %u\n",
            device->device.layout_count);
        *device_out = device;
    }

    LeaveCriticalSection(&device->device.lock);
out:
    dprintf(FDLVL, "<-- pnfs_file_device_get() returning %s\n",
        pnfs_error_string(status));
    return status;
}

pnfs_file_device_list_create()

enum pnfs_status pnfs_file_device_list_create

(

OUT struct pnfs_file_device_list **

devices_out

)

Definition at line 124 of file pnfs_device.c.

{
    enum pnfs_status status = PNFS_SUCCESS;
    struct pnfs_file_device_list *devices;

    devices = calloc(1, sizeof(struct pnfs_file_device_list));
    if (devices == NULL) {
        status = PNFSERR_RESOURCES;
        goto out;
    }

    list_init(&devices->head);
    InitializeCriticalSection(&devices->lock);

    *devices_out = devices;
out:
    return status;
}

Referenced by pnfs_client_init().

pnfs_file_device_list_free()

void pnfs_file_device_list_free

(

IN struct pnfs_file_device_list *

devices

)

Definition at line 144 of file pnfs_device.c.

{
    struct list_entry *entry, *tmp;

    EnterCriticalSection(&devices->lock);

    list_for_each_tmp(entry, tmp, &devices->head)
        file_device_free(device_entry(entry));

    LeaveCriticalSection(&devices->lock);
    DeleteCriticalSection(&devices->lock);
    free(devices);
}

Referenced by nfs41_client_free().

pnfs_file_device_list_invalidate()

void pnfs_file_device_list_invalidate

(

IN struct pnfs_file_device_list *

devices

)

Definition at line 159 of file pnfs_device.c.

{
    struct list_entry *entry, *tmp;
    pnfs_file_device *device;

    dprintf(FDLVL, "--> pnfs_file_device_list_invalidate()\n");

    EnterCriticalSection(&devices->lock);

    list_for_each_tmp(entry, tmp, &devices->head) {
        device = device_entry(entry);
        EnterCriticalSection(&device->device.lock);
        /* if there are layouts still using the device, flag it
         * as revoked and clean up on last reference */
        if (device->device.layout_count) {
            device->device.status |= PNFS_DEVICE_REVOKED;
            LeaveCriticalSection(&device->device.lock);
        } else {
            LeaveCriticalSection(&device->device.lock);
            /* no layouts are using it, so it's safe to free */
            list_remove(entry);
            file_device_free(device);
        }
    }

    LeaveCriticalSection(&devices->lock);

    dprintf(FDLVL, "<-- pnfs_file_device_list_invalidate()\n");
}

Referenced by file_layout_recall_all(), and file_layout_recall_fsid().

pnfs_file_device_notify()

enum pnfs_status pnfs_file_device_notify	(	IN struct pnfs_file_device_list *	devices,
		IN const struct notify_deviceid4 *	change
	)

Definition at line 328 of file pnfs_device.c.

{
    struct list_entry *entry;
    enum pnfs_status status = PNFSERR_NO_DEVICE;

    dprintf(FDLVL, "--> pnfs_file_device_notify(%u, %0llX:%0llX)\n",
        change->type, change->deviceid);

    if (change->layouttype != PNFS_LAYOUTTYPE_FILE) {
        status = PNFSERR_NOT_SUPPORTED;
        goto out;
    }

    EnterCriticalSection(&devices->lock);

    entry = list_search(&devices->head, change->deviceid, deviceid_compare);
    if (entry) {
        dprintf(FDLVL, "found file device %p\n", device_entry(entry));

        if (change->type == NOTIFY_DEVICEID4_CHANGE) {
            /* if (change->immediate) ... */
            dprintf(FDLVL, "CHANGE (%u)\n", change->immediate);
        } else if (change->type == NOTIFY_DEVICEID4_DELETE) {
            /* This notification MUST NOT be sent if the client
             * has a layout that refers to the device ID. */
            dprintf(FDLVL, "DELETE\n");
        }
        status = PNFS_SUCCESS;
    }

    LeaveCriticalSection(&devices->lock);
out:
    dprintf(FDLVL, "<-- pnfs_file_device_notify() returning %s\n",
        pnfs_error_string(status));
    return status;
}

Referenced by handle_cb_notify_deviceid().

pnfs_file_device_put()

void pnfs_file_device_put

(

IN pnfs_file_device *

device

)

Definition at line 245 of file pnfs_device.c.

{
    uint32_t count;
    EnterCriticalSection(&device->device.lock);
    count = --device->device.layout_count;
    dprintf(FDLVL, "pnfs_file_device_put() -> %u\n", count);

    /* if the device was revoked, remove/free the device on last reference */
    if (count == 0 && device->device.status & PNFS_DEVICE_REVOKED) {
        EnterCriticalSection(&device->devices->lock);
        list_remove(&device->entry);
        LeaveCriticalSection(&device->devices->lock);

        LeaveCriticalSection(&device->device.lock);

        file_device_free(device);
        dprintf(FDLVL, "revoked file device freed after last reference\n");
    } else {
        LeaveCriticalSection(&device->device.lock);
    }
}

Referenced by file_layout_free().