path: root/xlators/experimental/fdl/src/recon-tmpl.c

#pragma fragment PROLOG
#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif

#include "glusterfs.h"
#include "iatt.h"
#include "syncop.h"
#include "xlator.h"
#include "glfs-internal.h"

#include "fdl.h"

#define GFAPI_SUCCESS 0

inode_t *
recon_get_inode (glfs_t *fs, uuid_t gfid)
{
        inode_t         *inode;
        loc_t           loc     = {NULL,};
        struct iatt     iatt;
        int             ret;
        inode_t         *newinode;

        inode = inode_find (fs->active_subvol->itable, gfid);
        if (inode) {
                printf ("=== FOUND %s IN TABLE\n", uuid_utoa(gfid));
                return inode;
        }

        loc.inode = inode_new (fs->active_subvol->itable);
        if (!loc.inode) {
                return NULL;
        }
        gf_uuid_copy (loc.inode->gfid, gfid);
        gf_uuid_copy (loc.gfid, gfid);

        printf ("=== DOING LOOKUP FOR %s\n", uuid_utoa(gfid));

        ret = syncop_lookup (fs->active_subvol, &loc, &iatt,
                             NULL, NULL, NULL);
        if (ret != GFAPI_SUCCESS) {
                fprintf (stderr, "syncop_lookup failed (%d)\n", ret);
                return NULL;
        }

        newinode = inode_link (loc.inode, NULL, NULL, &iatt);
        if (newinode) {
                inode_lookup (newinode);
        }

        return newinode;
}

#pragma fragment DICT
        dict_t  *@ARGNAME@;

        @ARGNAME@ = dict_new();
        if (!@ARGNAME@) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@;

        {
                int     key_len, data_len;
                char    *key_ptr;
                int     garbage;
                for (;;) {
                        key_len = *((int *)new_meta);
                        new_meta += sizeof(int);
                        if (!key_len) {
                                break;
                        }
                        key_ptr = new_meta;
                        new_meta += key_len;
                        data_len = *((int *)new_meta);
                        new_meta += sizeof(int);
                        garbage = dict_set_static_bin (@ARGNAME@, key_ptr,
                                                       new_meta, data_len);
                        /* TBD: check error from dict_set_static_bin */
                        (void)garbage;
                        new_meta += data_len;
                }
        }

#pragma fragment DICT_CLEANUP
cleanup_@ARGNAME@:
        dict_unref (@ARGNAME@);

#pragma fragment DOUBLE
        @ARGTYPE@       @ARGNAME@       = *((@ARGTYPE@ *)new_meta);
        new_meta += sizeof(uint64_t);

#pragma fragment FD
        inode_t *@ARGNAME@_ino;
        fd_t    *@ARGNAME@;

        @ARGNAME@_ino = recon_get_inode (fs, *((uuid_t *)new_meta));
        new_meta += 16;
        if (!@ARGNAME@_ino) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@_ino;

        @ARGNAME@ = fd_anonymous (@ARGNAME@_ino);
        if (!@ARGNAME@) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@;

#pragma fragment FD_CLEANUP
cleanup_@ARGNAME@:
        fd_unref (@ARGNAME@);
cleanup_@ARGNAME@_ino:
        inode_unref (@ARGNAME@_ino);

#pragma fragment NEW_FD
        /*
         * This pseudo-type is only used for create, and in that case we know
         * we'll be using loc.inode, so it's not worth generalizing to take an
         * extra argument.
         */
        fd_t    *@ARGNAME@      = fd_anonymous (loc.inode);

        if (!fd) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@;
        new_meta += 16;

#pragma fragment NEW_FD_CLEANUP
cleanup_@ARGNAME@:
        fd_unref (@ARGNAME@);

#pragma fragment INTEGER
        @ARGTYPE@       @ARGNAME@       = *((@ARGTYPE@ *)new_meta);

        new_meta += sizeof(@ARGTYPE@);

#pragma fragment LOC
        loc_t           @ARGNAME@       = { NULL, };

        @ARGNAME@.inode = recon_get_inode (fs, *((uuid_t *)new_meta));
        if (!@ARGNAME@.inode) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@;
        gf_uuid_copy (@ARGNAME@.gfid, @ARGNAME@.inode->gfid);
        new_meta += 16;
        new_meta += 16; /* skip over pargfid */
        if (*(new_meta++)) {
                @ARGNAME@.name = new_meta;
                new_meta += strlen(new_meta) + 1;
        }

#pragma fragment LOC_CLEANUP
cleanup_@ARGNAME@:
        loc_wipe (&@ARGNAME@);

#pragma fragment PARENT_LOC
        loc_t           @ARGNAME@       = { NULL, };

        new_meta += 16; /* skip over gfid */
        @ARGNAME@.parent = recon_get_inode (fs, *((uuid_t *)new_meta));
        if (!@ARGNAME@.parent) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@;
        gf_uuid_copy (@ARGNAME@.pargfid, @ARGNAME@.parent->gfid);
        new_meta += 16;
        if (!*(new_meta++)) {
                goto *err_label;
        }
        @ARGNAME@.name = new_meta;
        new_meta += strlen(new_meta) + 1;

        @ARGNAME@.inode = inode_new (fs->active_subvol->itable);
        if (!@ARGNAME@.inode) {
                goto *err_label;
        }

#pragma fragment PARENT_LOC_CLEANUP
cleanup_@ARGNAME@:
        loc_wipe (&@ARGNAME@);

#pragma fragment STRING
        char    *@ARGNAME@;
        if (*(new_meta++)) {
                @ARGNAME@ = new_meta;
                new_meta += (strlen(new_meta) + 1);
        }
        else {
                goto *err_label;
        }

#pragma fragment VECTOR
        struct iovec    @ARGNAME@;

        @ARGNAME@.iov_len = *((size_t *)new_meta);
        new_meta += sizeof(@ARGNAME@.iov_len);
        @ARGNAME@.iov_base = new_data;
        new_data += @ARGNAME@.iov_len;

#pragma fragment IATT
        struct iatt     @ARGNAME@;
        {
                @ARGNAME@.ia_prot = *((ia_prot_t *)new_meta);
                new_meta += sizeof(ia_prot_t);
                uint32_t *myints = (uint32_t *)new_meta;
                @ARGNAME@.ia_uid = myints[0];
                @ARGNAME@.ia_gid = myints[1];
                @ARGNAME@.ia_atime = myints[2];
                @ARGNAME@.ia_atime_nsec = myints[3];
                @ARGNAME@.ia_mtime = myints[4];
                @ARGNAME@.ia_mtime_nsec = myints[5];
                new_meta += sizeof(*myints) * 6;
        }

#pragma fragment IOBREF
        struct iobref   *@ARGNAME@;

        @ARGNAME@ = iobref_new();
        if (!@ARGNAME@) {
                goto *err_label;
        }
        err_label = &&cleanup_@ARGNAME@;

#pragma fragment IOBREF_CLEANUP
cleanup_@ARGNAME@:
        iobref_unref (@ARGNAME@);

#pragma fragment LINK
        /* TBD: check error */
        inode_t *new_inode = inode_link (@INODE_ARG@, NULL, NULL, @IATT_ARG@);
        if (new_inode) {
                inode_lookup (new_inode);
        }

#pragma fragment FOP
int
fdl_replay_@NAME@ (glfs_t *fs, char **old_meta, char **old_data)
{
        char    *new_meta	= *old_meta;
        char	*new_data	= *old_data;
        int     ret;
        int     status          = 0xbad;
        void    *err_label      = &&done;

@FUNCTION_BODY@

        ret = syncop_@NAME@ (fs->active_subvol, @SYNCOP_ARGS@, NULL);
        if (ret != @SUCCESS_VALUE@) {
                fprintf (stderr, "syncop_@NAME@ returned %d", ret);
                goto *err_label;
        }

@LINKS@

        status = 0;

@CLEANUPS@

done:
        *old_meta = new_meta;
        *old_data = new_data;
        return status;
}

#pragma fragment CASE
        case GF_FOP_@UPNAME@:
                printf ("=== GF_FOP_@UPNAME@\n");
                if (fdl_replay_@NAME@ (fs, &new_meta, &new_data) != 0) {
                        goto done;
                }
                recognized = 1;
                break;

#pragma fragment EPILOG
int
recon_execute (glfs_t *fs, char **old_meta, char **old_data)
{
        char            *new_meta       = *old_meta;
        char            *new_data       = *old_data;
        int             recognized      = 0;
        event_header_t  *eh;

        eh = (event_header_t *)new_meta;
        new_meta += sizeof (*eh);

        /* TBD: check event_type instead of assuming NEW_REQUEST */

        switch (eh->fop_type) {
@SWITCH_BODY@

        default:
                printf ("unknown fop %u\n", eh->fop_type);
        }

done:
        *old_meta = new_meta;
        *old_data = new_data;
        return recognized;
}