/*      $NetBSD: puffs_compat.c,v 1.8 2019/12/12 02:15:43 pgoyette Exp $        */

/*
* Copyright (c) 2010 Antti Kantee.  All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

/*
* This file handles puffs PDUs so that they are compatible between
* 32bit<->64bit time_t/dev_t.  It enables running a -current kernel
* against a 5.0 userland (assuming the protocol otherwise matches!).
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: puffs_compat.c,v 1.8 2019/12/12 02:15:43 pgoyette Exp $");

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/kmem.h>
#include <sys/kthread.h>
#include <sys/lock.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/atomic.h>
#include <sys/compat_stub.h>

#include <dev/putter/putter_sys.h>

#include <fs/puffs/puffs_msgif.h>
#include <fs/puffs/puffs_sys.h>

#include <compat/sys/time.h>

/*
* compat types
*/
struct vattr50 {
       enum vtype              va_type;
       mode_t                  va_mode;
       nlink_t                 va_nlink;
       uid_t                   va_uid;
       gid_t                   va_gid;
       uint32_t                va_fsid;
       ino_t                   va_fileid;
       u_quad_t                va_size;
       long                    va_blocksize;
       struct timespec50       va_atime;
       struct timespec50       va_mtime;
       struct timespec50       va_ctime;
       struct timespec50       va_birthtime;
       u_long                  va_gen;
       u_long                  va_flags;
       uint32_t                va_rdev;
       u_quad_t                va_bytes;
       u_quad_t                va_filerev;
       u_int                   va_vaflags;
       long                    va_spare;
};

struct puffs50_vfsmsg_fhtonode {
       struct puffs_req        pvfsr_pr;

       void                    *pvfsr_fhcookie;        /* IN   */
       enum vtype              pvfsr_vtype;            /* IN   */
       voff_t                  pvfsr_size;             /* IN   */
       uint32_t                pvfsr_rdev;             /* IN   */

       size_t                  pvfsr_dsize;            /* OUT */
       uint8_t                 pvfsr_data[0]           /* OUT, XXX */
                                       __aligned(ALIGNBYTES+1);
};

struct puffs50_vnmsg_lookup {
       struct puffs_req        pvn_pr;

       struct puffs_kcn        pvnr_cn;                /* OUT  */
       struct puffs_kcred      pvnr_cn_cred;           /* OUT  */

       puffs_cookie_t          pvnr_newnode;           /* IN   */
       enum vtype              pvnr_vtype;             /* IN   */
       voff_t                  pvnr_size;              /* IN   */
       uint32_t                pvnr_rdev;              /* IN   */
};

struct puffs50_vnmsg_create {
       struct puffs_req        pvn_pr;

       struct puffs_kcn        pvnr_cn;                /* OUT  */
       struct puffs_kcred      pvnr_cn_cred;           /* OUT  */

       struct vattr50          pvnr_va;                /* OUT  */
       puffs_cookie_t          pvnr_newnode;           /* IN   */
};

struct puffs50_vnmsg_mknod {
       struct puffs_req        pvn_pr;

       struct puffs_kcn        pvnr_cn;                /* OUT  */
       struct puffs_kcred      pvnr_cn_cred;           /* OUT  */

       struct vattr50          pvnr_va;                /* OUT  */
       puffs_cookie_t          pvnr_newnode;           /* IN   */
};

#define puffs50_vnmsg_setattr puffs50_vnmsg_setgetattr
#define puffs50_vnmsg_getattr puffs50_vnmsg_setgetattr
struct puffs50_vnmsg_setgetattr {
       struct puffs_req        pvn_pr;

       struct puffs_kcred      pvnr_cred;              /* OUT  */
       struct vattr50          pvnr_va;                /* IN/OUT (op depend) */
};

struct puffs50_vnmsg_mkdir {
       struct puffs_req        pvn_pr;

       struct puffs_kcn        pvnr_cn;                /* OUT  */
       struct puffs_kcred      pvnr_cn_cred;           /* OUT  */

       struct vattr50          pvnr_va;                /* OUT  */
       puffs_cookie_t          pvnr_newnode;           /* IN   */
};

struct puffs50_vnmsg_symlink {
       struct puffs_req        pvn_pr;

       struct puffs_kcn        pvnr_cn;                /* OUT  */
       struct puffs_kcred      pvnr_cn_cred;           /* OUT  */

       struct vattr50          pvnr_va;                /* OUT  */
       puffs_cookie_t          pvnr_newnode;           /* IN   */
       char                    pvnr_link[MAXPATHLEN];  /* OUT  */
};

/*
* vattr translation routines
*/

static void
vattr_to_50(const struct vattr *va, struct vattr50 *va50)
{

       va50->va_type = va->va_type;
       va50->va_mode = va->va_mode;
       va50->va_nlink = va->va_nlink;
       va50->va_uid = va->va_uid;
       va50->va_gid = va->va_gid;
       va50->va_fsid = (uint64_t)va->va_fsid;
       va50->va_fileid = va->va_fileid;
       va50->va_size = va->va_size;
       va50->va_blocksize = va->va_blocksize;
       timespec_to_timespec50(&va->va_atime, &va50->va_atime);
       timespec_to_timespec50(&va->va_ctime, &va50->va_ctime);
       timespec_to_timespec50(&va->va_mtime, &va50->va_mtime);
       timespec_to_timespec50(&va->va_birthtime, &va50->va_birthtime);
       va50->va_gen = va->va_gen;
       va50->va_flags = va->va_flags;
       va50->va_rdev = (int32_t)va->va_rdev;
       va50->va_bytes = va->va_bytes;
       va50->va_filerev = va->va_filerev;
       va50->va_vaflags = va->va_flags;
}

static void
vattr_from_50(const struct vattr50 *va50, struct vattr *va)
{

       va->va_type = va50->va_type;
       va->va_mode = va50->va_mode;
       va->va_nlink = va50->va_nlink;
       va->va_uid = va50->va_uid;
       va->va_gid = va50->va_gid;
       va->va_fsid = (uint32_t)va50->va_fsid;
       va->va_fileid = va50->va_fileid;
       va->va_size = va50->va_size;
       va->va_blocksize = va50->va_blocksize;
       timespec50_to_timespec(&va50->va_atime, &va->va_atime);
       timespec50_to_timespec(&va50->va_ctime, &va->va_ctime);
       timespec50_to_timespec(&va50->va_mtime, &va->va_mtime);
       timespec50_to_timespec(&va50->va_birthtime, &va->va_birthtime);
       va->va_gen = va50->va_gen;
       va->va_flags = va50->va_flags;
       va->va_rdev = (uint32_t)va50->va_rdev;
       va->va_bytes = va50->va_bytes;
       va->va_filerev = va50->va_filerev;
       va->va_vaflags = va50->va_flags;
}

/*
* XXX: cannot assert that sleeping is possible
* (this always a valid assumption for now)
*/
#define INIT(name, extra)                                               \
       struct puffs50_##name *cmsg;                                    \
       struct puffs_##name *omsg;                                      \
       creq =kmem_zalloc(sizeof(struct puffs50_##name)+extra,KM_SLEEP);\
       cmsg = (struct puffs50_##name *)creq;                           \
       omsg = (struct puffs_##name *)oreq;                             \
       delta = sizeof(struct puffs50_##name)-sizeof(struct puffs_##name);
#define ASSIGN(field)                                                   \
       cmsg->field = omsg->field;

int
puffs_compat_outgoing(struct puffs_req *oreq,
       struct puffs_req **creqp, ssize_t *deltap)
{
       int rv = ENOSYS;        /* non-zero return ==> false */
       struct puffs_req *creq = NULL;
       ssize_t delta = 0;

       if (PUFFSOP_OPCLASS(oreq->preq_opclass) == PUFFSOP_VFS
           && oreq->preq_optype == PUFFS_VFS_FHTOVP) {
               INIT(vfsmsg_fhtonode,
                   ((struct puffs_vfsmsg_fhtonode *)oreq)->pvfsr_dsize);

               ASSIGN(pvfsr_pr);
               ASSIGN(pvfsr_dsize);
               memcpy(cmsg->pvfsr_data, omsg->pvfsr_data, cmsg->pvfsr_dsize);
       } else if (PUFFSOP_OPCLASS(oreq->preq_opclass) == PUFFSOP_VN) {
               switch (oreq->preq_optype) {
               case PUFFS_VN_LOOKUP:
               {
                       INIT(vnmsg_lookup, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cn);
                       ASSIGN(pvnr_cn_cred);

                       break;
               }

               case PUFFS_VN_CREATE:
               {
                       INIT(vnmsg_create, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cn);
                       ASSIGN(pvnr_cn_cred);
                       vattr_to_50(&omsg->pvnr_va, &cmsg->pvnr_va);

                       break;
               }

               case PUFFS_VN_MKNOD:
               {
                       INIT(vnmsg_mknod, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cn);
                       ASSIGN(pvnr_cn_cred);
                       vattr_to_50(&omsg->pvnr_va, &cmsg->pvnr_va);

                       break;
               }

               case PUFFS_VN_MKDIR:
               {
                       INIT(vnmsg_mkdir, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cn);
                       ASSIGN(pvnr_cn_cred);
                       vattr_to_50(&omsg->pvnr_va, &cmsg->pvnr_va);

                       break;
               }

               case PUFFS_VN_SYMLINK:
               {
                       INIT(vnmsg_symlink, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cn);
                       ASSIGN(pvnr_cn_cred);
                       vattr_to_50(&omsg->pvnr_va, &cmsg->pvnr_va);
                       memcpy(cmsg->pvnr_link, omsg->pvnr_link,
                           sizeof(cmsg->pvnr_link));

                       break;
               }

               case PUFFS_VN_SETATTR:
               {
                       INIT(vnmsg_setattr, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cred);
                       vattr_to_50(&omsg->pvnr_va, &cmsg->pvnr_va);

                       break;
               }
               case PUFFS_VN_GETATTR:
               {
                       INIT(vnmsg_getattr, 0);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_cred);

                       break;
               }

               default:
                       break;
               }
       }

       if (creq) {
               *creqp = creq;
               *deltap = delta;
               rv = 0;
       }

       return rv;
}
#undef INIT
#undef ASSIGN

#define INIT(name)                                                      \
       struct puffs50_##name *cmsg = (void *)preq;                     \
       struct puffs_##name *omsg = (void *)creq;
#define ASSIGN(field)                                                   \
       omsg->field = cmsg->field;

void
puffs_compat_incoming(struct puffs_req *preq, struct puffs_req *creq)
{

       if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VFS
           && preq->preq_optype == PUFFS_VFS_FHTOVP) {
               INIT(vfsmsg_fhtonode);

               ASSIGN(pvfsr_pr);

               ASSIGN(pvfsr_fhcookie);
               ASSIGN(pvfsr_vtype);
               ASSIGN(pvfsr_size);
               ASSIGN(pvfsr_rdev);
       } else if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN) {
               switch (preq->preq_optype) {
               case PUFFS_VN_LOOKUP:
               {
                       INIT(vnmsg_lookup);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_newnode);
                       ASSIGN(pvnr_vtype);
                       ASSIGN(pvnr_size);
                       ASSIGN(pvnr_rdev);

                       break;
               }

               case PUFFS_VN_CREATE:
               {
                       INIT(vnmsg_create);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_newnode);

                       break;
               }

               case PUFFS_VN_MKNOD:
               {
                       INIT(vnmsg_mknod);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_newnode);

                       break;
               }

               case PUFFS_VN_MKDIR:
               {
                       INIT(vnmsg_mkdir);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_newnode);

                       break;
               }

               case PUFFS_VN_SYMLINK:
               {
                       INIT(vnmsg_symlink);

                       ASSIGN(pvn_pr);
                       ASSIGN(pvnr_newnode);

                       break;
               }

               case PUFFS_VN_SETATTR:
               {
                       INIT(vnmsg_setattr);

                       ASSIGN(pvn_pr);

                       break;
               }
               case PUFFS_VN_GETATTR:
               {
                       INIT(vnmsg_getattr);

                       ASSIGN(pvn_pr);
                       vattr_from_50(&cmsg->pvnr_va, &omsg->pvnr_va);

                       break;
               }

               default:
                       panic("puffs compat ops come in pairs");
               }
       }
}

void puffs_50_init(void)
{

       MODULE_HOOK_SET(puffs_out_50_hook, puffs_compat_outgoing);
       MODULE_HOOK_SET(puffs_in_50_hook, puffs_compat_incoming);
}

void puffs_50_fini(void)
{

       MODULE_HOOK_UNSET(puffs_out_50_hook);
       MODULE_HOOK_UNSET(puffs_in_50_hook);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.