/*      $NetBSD: dtfs_vnops.c,v 1.10 2013/10/19 17:45:00 christos Exp $ */

/*
* Copyright (c) 2006  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.
*/

#include <sys/types.h>
#include <sys/poll.h>

#include <assert.h>
#include <errno.h>
#include <puffs.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>

#include "dtfs.h"

int
dtfs_node_lookup(struct puffs_usermount *pu, void *opc,
       struct puffs_newinfo *pni, const struct puffs_cn *pcn)
{
       struct puffs_node *pn_dir = opc;
       struct dtfs_file *df = DTFS_CTOF(opc);
       struct dtfs_dirent *dfd;
       extern int straightflush;
       int rv;

       /* parent dir? */
       if (PCNISDOTDOT(pcn)) {
               if (df->df_dotdot == NULL)
                       return ENOENT;

               assert(df->df_dotdot->pn_va.va_type == VDIR);
               puffs_newinfo_setcookie(pni, df->df_dotdot);
               puffs_newinfo_setvtype(pni, df->df_dotdot->pn_va.va_type);

               return 0;
       }

       dfd = dtfs_dirgetbyname(df, pcn->pcn_name, pcn->pcn_namelen);
       if (dfd) {
               if ((pcn->pcn_flags & NAMEI_ISLASTCN) &&
                   (pcn->pcn_nameiop == NAMEI_DELETE)) {
                       rv = puffs_access(VDIR, pn_dir->pn_va.va_mode,
                           pn_dir->pn_va.va_uid, pn_dir->pn_va.va_gid,
                           PUFFS_VWRITE, pcn->pcn_cred);
                       if (rv)
                               return rv;
               }
               puffs_newinfo_setcookie(pni, dfd->dfd_node);
               puffs_newinfo_setvtype(pni, dfd->dfd_node->pn_va.va_type);
               puffs_newinfo_setsize(pni, dfd->dfd_node->pn_va.va_size);
               puffs_newinfo_setrdev(pni, dfd->dfd_node->pn_va.va_rdev);

               if (straightflush)
                       puffs_flush_pagecache_node(pu, dfd->dfd_node);

               return 0;
       }

       if ((pcn->pcn_flags & NAMEI_ISLASTCN)
           && (pcn->pcn_nameiop == NAMEI_CREATE ||
               pcn->pcn_nameiop == NAMEI_RENAME)) {
               rv = puffs_access(VDIR, pn_dir->pn_va.va_mode,
                   pn_dir->pn_va.va_uid, pn_dir->pn_va.va_gid,
                   PUFFS_VWRITE, pcn->pcn_cred);
               if (rv)
                       return rv;
       }

       return ENOENT;
}

int
dtfs_node_access(struct puffs_usermount *pu, void *opc, int acc_mode,
       const struct puffs_cred *pcr)
{
       struct puffs_node *pn = opc;

       return puffs_access(pn->pn_va.va_type, pn->pn_va.va_mode,
           pn->pn_va.va_uid, pn->pn_va.va_gid, acc_mode, pcr);
}

int
dtfs_node_setattr(struct puffs_usermount *pu, void *opc,
       const struct vattr *va, const struct puffs_cred *pcr)
{
       struct puffs_node *pn = opc;
       int rv;

       /* check permissions */
       if (va->va_flags != PUFFS_VNOVAL)
               return EOPNOTSUPP;

       if (va->va_uid != PUFFS_VNOVAL || va->va_gid != PUFFS_VNOVAL) {
               rv = puffs_access_chown(pn->pn_va.va_uid, pn->pn_va.va_gid,
                   va->va_uid, va->va_gid, pcr);
               if (rv)
                       return rv;
       }

       if (va->va_mode != PUFFS_VNOVAL) {
               rv = puffs_access_chmod(pn->pn_va.va_uid, pn->pn_va.va_gid,
                   pn->pn_va.va_type, va->va_mode, pcr);
               if (rv)
                       return rv;
       }

       if ((va->va_atime.tv_sec != PUFFS_VNOVAL
             && va->va_atime.tv_nsec != PUFFS_VNOVAL)
           || (va->va_mtime.tv_sec != PUFFS_VNOVAL
             && va->va_mtime.tv_nsec != PUFFS_VNOVAL)) {
               rv = puffs_access_times(pn->pn_va.va_uid, pn->pn_va.va_gid,
                   pn->pn_va.va_mode, va->va_vaflags & VA_UTIMES_NULL, pcr);
               if (rv)
                       return rv;
       }

       if (va->va_size != PUFFS_VNOVAL) {
               switch (pn->pn_va.va_type) {
               case VREG:
                       dtfs_setsize(pn, va->va_size);
                       pn->pn_va.va_bytes = va->va_size;
                       break;
               case VBLK:
               case VCHR:
               case VFIFO:
                       break;
               case VDIR:
                       return EISDIR;
               default:
                       return EOPNOTSUPP;
               }
       }

       puffs_setvattr(&pn->pn_va, va);

       return 0;
}

/* create a new node in the parent directory specified by opc */
int
dtfs_node_create(struct puffs_usermount *pu, void *opc,
       struct puffs_newinfo *pni, const struct puffs_cn *pcn,
       const struct vattr *va)
{
       struct puffs_node *pn_parent = opc;
       struct puffs_node *pn_new;

       if (!(va->va_type == VREG || va->va_type == VSOCK))
               return ENODEV;

       pn_new = dtfs_genfile(pn_parent, pcn, va->va_type);
       puffs_setvattr(&pn_new->pn_va, va);

       puffs_newinfo_setcookie(pni, pn_new);

       return 0;
}

int
dtfs_node_remove(struct puffs_usermount *pu, void *opc, void *targ,
       const struct puffs_cn *pcn)
{
       struct puffs_node *pn_parent = opc;
       struct puffs_node *pn = targ;

       if (pn->pn_va.va_type == VDIR)
               return EPERM;

       dtfs_nukenode(targ, pn_parent, pcn->pcn_name, pcn->pcn_namelen);

       if (pn->pn_va.va_nlink == 0)
               puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);

       return 0;
}

int
dtfs_node_mkdir(struct puffs_usermount *pu, void *opc,
       struct puffs_newinfo *pni, const struct puffs_cn *pcn,
       const struct vattr *va)
{
       struct puffs_node *pn_parent = opc;
       struct puffs_node *pn_new;

       pn_new = dtfs_genfile(pn_parent, pcn, VDIR);
       puffs_setvattr(&pn_new->pn_va, va);

       puffs_newinfo_setcookie(pni, pn_new);

       return 0;
}

int
dtfs_node_rmdir(struct puffs_usermount *pu, void *opc, void *targ,
       const struct puffs_cn *pcn)
{
       struct puffs_node *pn_parent = opc;
       struct dtfs_file *df = DTFS_CTOF(targ);

       if (!LIST_EMPTY(&df->df_dirents))
               return ENOTEMPTY;

       dtfs_nukenode(targ, pn_parent, pcn->pcn_name, pcn->pcn_namelen);
       puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);

       return 0;
}

int
dtfs_node_readdir(struct puffs_usermount *pu, void *opc,
       struct dirent *dent, off_t *readoff, size_t *reslen,
       const struct puffs_cred *pcr,
       int *eofflag, off_t *cookies, size_t *ncookies)
{
       struct puffs_node *pn = opc;
       struct puffs_node *pn_nth;
       struct dtfs_dirent *dfd_nth;

       if (pn->pn_va.va_type != VDIR)
               return ENOTDIR;

       dtfs_updatetimes(pn, 1, 0, 0);

       *ncookies = 0;
again:
       if (*readoff == DENT_DOT || *readoff == DENT_DOTDOT) {
               puffs_gendotdent(&dent, pn->pn_va.va_fileid, *readoff, reslen);
               (*readoff)++;
               PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
               goto again;
       }

       for (;;) {
               dfd_nth = dtfs_dirgetnth(pn->pn_data, DENT_ADJ(*readoff));
               if (!dfd_nth) {
                       *eofflag = 1;
                       break;
               }
               pn_nth = dfd_nth->dfd_node;

               if (!puffs_nextdent(&dent, dfd_nth->dfd_name,
                   pn_nth->pn_va.va_fileid,
                   puffs_vtype2dt(pn_nth->pn_va.va_type),
                   reslen))
                       break;

               (*readoff)++;
               PUFFS_STORE_DCOOKIE(cookies, ncookies, *readoff);
       }

       return 0;
}

int
dtfs_node_poll(struct puffs_usermount *pu, void *opc, int *events)
{
       struct dtfs_mount *dtm = puffs_getspecific(pu);
       struct dtfs_poll dp;
       struct itimerval it;

       memset(&it, 0, sizeof(struct itimerval));
       it.it_value.tv_sec = 4;
       if (setitimer(ITIMER_REAL, &it, NULL) == -1)
               return errno;

       dp.dp_pcc = puffs_cc_getcc(pu);
       LIST_INSERT_HEAD(&dtm->dtm_pollent, &dp, dp_entries);
       puffs_cc_yield(dp.dp_pcc);

       *events = *events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
       return 0;
}

int
dtfs_node_mmap(struct puffs_usermount *pu, void *opc, vm_prot_t prot,
       const struct puffs_cred *pcr)
{
       struct dtfs_mount *dtm = puffs_getspecific(pu);

       if ((dtm->dtm_allowprot & prot) != prot)
               return EACCES;

       return 0;
}

int
dtfs_node_rename(struct puffs_usermount *pu, void *opc, void *src,
       const struct puffs_cn *pcn_src, void *targ_dir, void *targ,
       const struct puffs_cn *pcn_targ)
{
       struct dtfs_dirent *dfd_src;
       struct dtfs_file *df_targ;
       struct puffs_node *pn_sdir = opc;
       struct puffs_node *pn_sfile = src;
       struct puffs_node *pn_tdir = targ_dir;
       struct puffs_node *pn_tfile = targ;

       /* check that we don't do the old amigados trick */
       if (pn_sfile->pn_va.va_type == VDIR) {
               if (dtfs_isunder(pn_tdir, pn_sfile))
                       return EINVAL;

               if ((pcn_src->pcn_namelen == 1 && pcn_src->pcn_name[0]=='.') ||
                   opc == src ||
                   PCNISDOTDOT(pcn_src) ||
                   PCNISDOTDOT(pcn_targ)) {
                       return EINVAL;
               }
       }

       dfd_src = dtfs_dirgetbyname(DTFS_PTOF(pn_sdir),
           pcn_src->pcn_name, pcn_src->pcn_namelen);

       /* does it still exist, or did someone race us here? */
       if (dfd_src == NULL) {
               return ENOENT;
       }

       /* if there's a target file, nuke it for atomic replacement */
       if (pn_tfile) {
               if (pn_tfile->pn_va.va_type == VDIR) {
                       df_targ = DTFS_CTOF(pn_tfile);
                       if (!LIST_EMPTY(&df_targ->df_dirents))
                               return ENOTEMPTY;
               }
               dtfs_nukenode(pn_tfile, pn_tdir,
                   pcn_targ->pcn_name, pcn_targ->pcn_namelen);
       }

       /* out with the old */
       dtfs_removedent(pn_sdir, dfd_src);
       /* and in with the new */
       dtfs_adddent(pn_tdir, dfd_src);

       /* update name */
       free(dfd_src->dfd_name);
       dfd_src->dfd_name = estrndup(pcn_targ->pcn_name,pcn_targ->pcn_namelen);
       dfd_src->dfd_namelen = strlen(dfd_src->dfd_name);

       dtfs_updatetimes(src, 0, 1, 0);

       return 0;
}

int
dtfs_node_link(struct puffs_usermount *pu, void *opc, void *targ,
       const struct puffs_cn *pcn)
{
       struct puffs_node *pn_dir = opc;
       struct dtfs_dirent *dfd;

       dfd = emalloc(sizeof(struct dtfs_dirent));
       dfd->dfd_node = targ;
       dfd->dfd_name = estrndup(pcn->pcn_name, pcn->pcn_namelen);
       dfd->dfd_namelen = strlen(dfd->dfd_name);
       dtfs_adddent(pn_dir, dfd);

       dtfs_updatetimes(targ, 0, 1, 0);

       return 0;
}

int
dtfs_node_symlink(struct puffs_usermount *pu, void *opc,
       struct puffs_newinfo *pni, const struct puffs_cn *pcn_src,
       const struct vattr *va, const char *link_target)
{
       struct puffs_node *pn_parent = opc;
       struct puffs_node *pn_new;
       struct dtfs_file *df_new;

       if (va->va_type != VLNK)
               return ENODEV;

       pn_new = dtfs_genfile(pn_parent, pcn_src, VLNK);
       puffs_setvattr(&pn_new->pn_va, va);
       df_new = DTFS_PTOF(pn_new);
       df_new->df_linktarget = estrdup(link_target);
       pn_new->pn_va.va_size = strlen(df_new->df_linktarget);

       puffs_newinfo_setcookie(pni, pn_new);

       return 0;
}

int
dtfs_node_readlink(struct puffs_usermount *pu, void *opc,
       const struct puffs_cred *cred, char *linkname, size_t *linklen)
{
       struct dtfs_file *df = DTFS_CTOF(opc);
       struct puffs_node *pn = opc;

       assert(pn->pn_va.va_type == VLNK);
       strlcpy(linkname, df->df_linktarget, *linklen);
       *linklen = strlen(linkname);

       return 0;
}

int
dtfs_node_mknod(struct puffs_usermount *pu, void *opc,
       struct puffs_newinfo *pni, const struct puffs_cn *pcn,
       const struct vattr *va)
{
       struct puffs_node *pn_parent = opc;
       struct puffs_node *pn_new;

       if (!(va->va_type == VBLK || va->va_type == VCHR
           || va->va_type == VFIFO))
               return EINVAL;

       pn_new = dtfs_genfile(pn_parent, pcn, va->va_type);
       puffs_setvattr(&pn_new->pn_va, va);

       puffs_newinfo_setcookie(pni, pn_new);

       return 0;
}

#define BLOCKOFF(a,b) ((a) & ((b)-1))
#define BLOCKLEFT(a,b) ((b) - BLOCKOFF(a,b))

/*
* Read operation, used both for VOP_READ and VOP_GETPAGES
*/
int
dtfs_node_read(struct puffs_usermount *pu, void *opc, uint8_t *buf,
       off_t offset, size_t *resid, const struct puffs_cred *pcr, int ioflag)
{
       struct puffs_node *pn = opc;
       struct dtfs_file *df = DTFS_CTOF(opc);
       quad_t xfer, origxfer;
       uint8_t *src, *dest;
       size_t copylen;

       if (pn->pn_va.va_type != VREG)
               return EISDIR;

       xfer = MIN(*resid, df->df_datalen - offset);
       if (xfer < 0)
               return EINVAL;

       dest = buf;
       origxfer = xfer;
       while (xfer > 0) {
               copylen = MIN(xfer, BLOCKLEFT(offset, DTFS_BLOCKSIZE));
               src = df->df_blocks[BLOCKNUM(offset, DTFS_BLOCKSHIFT)]
                   + BLOCKOFF(offset, DTFS_BLOCKSIZE);
               memcpy(dest, src, copylen);
               offset += copylen;
               dest += copylen;
               xfer -= copylen;
       }
       *resid -= origxfer;

       dtfs_updatetimes(pn, 1, 0, 0);

       return 0;
}

/*
* write operation on the wing
*/
int
dtfs_node_write(struct puffs_usermount *pu, void *opc, uint8_t *buf,
       off_t offset, size_t *resid, const struct puffs_cred *pcr, int ioflag)
{
       struct puffs_node *pn = opc;
       struct dtfs_file *df = DTFS_CTOF(opc);
       uint8_t *src, *dest;
       size_t copylen;

       if (pn->pn_va.va_type != VREG)
               return EISDIR;

       if (ioflag & PUFFS_IO_APPEND)
               offset = pn->pn_va.va_size;

       if (*resid + offset > pn->pn_va.va_size)
               dtfs_setsize(pn, *resid + offset);

       src = buf;
       while (*resid > 0) {
               int i;
               copylen = MIN(*resid, BLOCKLEFT(offset, DTFS_BLOCKSIZE));
               i = BLOCKNUM(offset, DTFS_BLOCKSHIFT);
               dest = df->df_blocks[i]
                   + BLOCKOFF(offset, DTFS_BLOCKSIZE);
               memcpy(dest, src, copylen);
               offset += copylen;
               dest += copylen;
               *resid -= copylen;
       }

       dtfs_updatetimes(pn, 0, 1, 1);

       return 0;
}

int
dtfs_node_pathconf(struct puffs_usermount *pu, puffs_cookie_t opc,
       int name, register_t *retval)
{

       switch (name) {
       case _PC_LINK_MAX:
               *retval = LINK_MAX;
               return 0;
       case _PC_NAME_MAX:
               *retval = NAME_MAX;
               return 0;
       case _PC_PATH_MAX:
               *retval = PATH_MAX;
               return 0;
       case _PC_PIPE_BUF:
               *retval = PIPE_BUF;
               return 0;
       case _PC_CHOWN_RESTRICTED:
               *retval = 1;
               return 0;
       case _PC_NO_TRUNC:
               *retval = 1;
               return 0;
       case _PC_SYNC_IO:
               *retval = 1;
               return 0;
       case _PC_FILESIZEBITS:
               *retval = 43; /* this one goes to 11 */
               return 0;
       case _PC_SYMLINK_MAX:
               *retval = MAXPATHLEN;
               return 0;
       case _PC_2_SYMLINKS:
               *retval = 1;
               return 0;
       default:
               return EINVAL;
       }
}

int
dtfs_node_inactive(struct puffs_usermount *pu, puffs_cookie_t opc)
{
       struct puffs_node *pn = opc;

       if (pn->pn_va.va_nlink == 0)
               puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N1);
       return 0;
}

int
dtfs_node_reclaim(struct puffs_usermount *pu, void *opc)
{
       struct puffs_node *pn = opc;

       if (pn->pn_va.va_nlink == 0)
               dtfs_freenode(pn);

       return 0;
}

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.