[BACK]Return to puffs_subr.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / fs / puffs

Annotation of src/sys/fs/puffs/puffs_subr.c, Revision 1.64.6.2

1.64.6.1  mjf         1: /*     $NetBSD$        */
1.1       pooka       2:
                      3: /*
1.53      pooka       4:  * Copyright (c) 2006, 2007  Antti Kantee.  All Rights Reserved.
1.1       pooka       5:  *
                      6:  * Development of this software was supported by the
1.53      pooka       7:  * Ulla Tuominen Foundation and the Finnish Cultural Foundation.
1.1       pooka       8:  *
                      9:  * Redistribution and use in source and binary forms, with or without
                     10:  * modification, are permitted provided that the following conditions
                     11:  * are met:
                     12:  * 1. Redistributions of source code must retain the above copyright
                     13:  *    notice, this list of conditions and the following disclaimer.
                     14:  * 2. Redistributions in binary form must reproduce the above copyright
                     15:  *    notice, this list of conditions and the following disclaimer in the
                     16:  *    documentation and/or other materials provided with the distribution.
                     17:  *
                     18:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
                     19:  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
                     20:  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
                     21:  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
                     22:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     23:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
                     24:  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     25:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     26:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     27:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     28:  * SUCH DAMAGE.
                     29:  */
                     30:
                     31: #include <sys/cdefs.h>
1.64.6.1  mjf        32: __KERNEL_RCSID(0, "$NetBSD$");
1.1       pooka      33:
                     34: #include <sys/param.h>
1.64.6.2! mjf        35: #include <sys/buf.h>
1.1       pooka      36: #include <sys/malloc.h>
                     37: #include <sys/mount.h>
1.31      pooka      38: #include <sys/namei.h>
                     39: #include <sys/poll.h>
1.56      ad         40: #include <sys/proc.h>
1.1       pooka      41:
                     42: #include <fs/puffs/puffs_msgif.h>
                     43: #include <fs/puffs/puffs_sys.h>
                     44:
1.19      pooka      45: #ifdef PUFFSDEBUG
1.10      pooka      46: int puffsdebug;
                     47: #endif
                     48:
1.1       pooka      49: void
1.36      pooka      50: puffs_makecn(struct puffs_kcn *pkcn, struct puffs_kcred *pkcr,
1.62      pooka      51:        const struct componentname *cn, int full)
1.1       pooka      52: {
                     53:
1.12      pooka      54:        pkcn->pkcn_nameiop = cn->cn_nameiop;
                     55:        pkcn->pkcn_flags = cn->cn_flags;
1.1       pooka      56:
1.38      pooka      57:        if (full) {
                     58:                (void)strcpy(pkcn->pkcn_name, cn->cn_nameptr);
                     59:        } else {
                     60:                (void)memcpy(pkcn->pkcn_name, cn->cn_nameptr, cn->cn_namelen);
                     61:                pkcn->pkcn_name[cn->cn_namelen] = '\0';
                     62:        }
1.12      pooka      63:        pkcn->pkcn_namelen = cn->cn_namelen;
1.38      pooka      64:        pkcn->pkcn_consume = 0;
1.36      pooka      65:
                     66:        puffs_credcvt(pkcr, cn->cn_cred);
1.1       pooka      67: }
                     68:
                     69: /*
1.36      pooka      70:  * Convert given credentials to struct puffs_kcred for userspace.
1.1       pooka      71:  */
                     72: void
1.36      pooka      73: puffs_credcvt(struct puffs_kcred *pkcr, const kauth_cred_t cred)
1.1       pooka      74: {
                     75:
1.36      pooka      76:        memset(pkcr, 0, sizeof(struct puffs_kcred));
1.1       pooka      77:
                     78:        if (cred == NOCRED || cred == FSCRED) {
1.36      pooka      79:                pkcr->pkcr_type = PUFFCRED_TYPE_INTERNAL;
1.1       pooka      80:                if (cred == NOCRED)
1.36      pooka      81:                        pkcr->pkcr_internal = PUFFCRED_CRED_NOCRED;
1.1       pooka      82:                if (cred == FSCRED)
1.36      pooka      83:                        pkcr->pkcr_internal = PUFFCRED_CRED_FSCRED;
1.1       pooka      84:        } else {
1.36      pooka      85:                pkcr->pkcr_type = PUFFCRED_TYPE_UUC;
                     86:                kauth_cred_to_uucred(&pkcr->pkcr_uuc, cred);
1.1       pooka      87:        }
                     88: }
                     89:
1.37      pooka      90: void
1.55      pooka      91: puffs_parkdone_asyncbioread(struct puffs_mount *pmp,
                     92:        struct puffs_req *preq, void *arg)
1.27      pooka      93: {
1.57      pooka      94:        struct puffs_vnmsg_read *read_msg = (void *)preq;
1.27      pooka      95:        struct buf *bp = arg;
                     96:        size_t moved;
                     97:
1.59      pooka      98:        DPRINTF(("%s\n", __func__));
                     99:
1.55      pooka     100:        bp->b_error = checkerr(pmp, preq->preq_rv, __func__);
1.27      pooka     101:        if (bp->b_error == 0) {
1.59      pooka     102:                if (read_msg->pvnr_resid > bp->b_bcount) {
                    103:                        puffs_senderr(pmp, PUFFS_ERR_READ, E2BIG,
                    104:                            "resid grew", preq->preq_cookie);
                    105:                        bp->b_error = E2BIG;
                    106:                } else {
                    107:                        moved = bp->b_bcount - read_msg->pvnr_resid;
                    108:                        bp->b_resid = read_msg->pvnr_resid;
                    109:
                    110:                        memcpy(bp->b_data, read_msg->pvnr_data, moved);
                    111:                }
                    112:        }
                    113:
                    114:        biodone(bp);
                    115: }
                    116:
                    117: void
                    118: puffs_parkdone_asyncbiowrite(struct puffs_mount *pmp,
                    119:        struct puffs_req *preq, void *arg)
                    120: {
                    121:        struct puffs_vnmsg_write *write_msg = (void *)preq;
                    122:        struct buf *bp = arg;
1.27      pooka     123:
1.59      pooka     124:        DPRINTF(("%s\n", __func__));
                    125:
                    126:        bp->b_error = checkerr(pmp, preq->preq_rv, __func__);
                    127:        if (bp->b_error == 0) {
                    128:                if (write_msg->pvnr_resid > bp->b_bcount) {
                    129:                        puffs_senderr(pmp, PUFFS_ERR_WRITE, E2BIG,
                    130:                            "resid grew", preq->preq_cookie);
                    131:                        bp->b_error = E2BIG;
                    132:                } else {
                    133:                        bp->b_resid = write_msg->pvnr_resid;
                    134:                }
1.27      pooka     135:        }
                    136:
                    137:        biodone(bp);
                    138: }
1.28      pooka     139:
1.44      pooka     140: /* XXX: userspace can leak kernel resources */
1.28      pooka     141: void
1.55      pooka     142: puffs_parkdone_poll(struct puffs_mount *pmp, struct puffs_req *preq, void *arg)
1.31      pooka     143: {
1.57      pooka     144:        struct puffs_vnmsg_poll *poll_msg = (void *)preq;
1.31      pooka     145:        struct puffs_node *pn = arg;
1.55      pooka     146:        int revents, error;
1.31      pooka     147:
1.55      pooka     148:        error = checkerr(pmp, preq->preq_rv, __func__);
                    149:        if (error)
1.57      pooka     150:                revents = poll_msg->pvnr_events;
1.31      pooka     151:        else
                    152:                revents = POLLERR;
                    153:
                    154:        mutex_enter(&pn->pn_mtx);
                    155:        pn->pn_revents |= revents;
                    156:        mutex_exit(&pn->pn_mtx);
                    157:
1.64.6.1  mjf       158:        selnotify(&pn->pn_sel, revents, 0);
1.31      pooka     159:
                    160:        puffs_releasenode(pn);
                    161: }
                    162:
                    163: void
1.28      pooka     164: puffs_mp_reference(struct puffs_mount *pmp)
                    165: {
                    166:
                    167:        KASSERT(mutex_owned(&pmp->pmp_lock));
                    168:        pmp->pmp_refcount++;
                    169: }
                    170:
                    171: void
                    172: puffs_mp_release(struct puffs_mount *pmp)
                    173: {
                    174:
                    175:        KASSERT(mutex_owned(&pmp->pmp_lock));
                    176:        if (--pmp->pmp_refcount == 0)
                    177:                cv_broadcast(&pmp->pmp_refcount_cv);
                    178: }
1.53      pooka     179:
                    180: void
                    181: puffs_gop_size(struct vnode *vp, off_t size, off_t *eobp,
                    182:        int flags)
                    183: {
                    184:
                    185:        *eobp = size;
                    186: }
                    187:
                    188: void
                    189: puffs_gop_markupdate(struct vnode *vp, int flags)
                    190: {
                    191:        int uflags = 0;
                    192:
                    193:        if (flags & GOP_UPDATE_ACCESSED)
                    194:                uflags |= PUFFS_UPDATEATIME;
                    195:        if (flags & GOP_UPDATE_MODIFIED)
                    196:                uflags |= PUFFS_UPDATEMTIME;
                    197:
1.60      pooka     198:        puffs_updatenode(VPTOPP(vp), uflags, 0);
1.53      pooka     199: }
1.58      pooka     200:
                    201: void
                    202: puffs_senderr(struct puffs_mount *pmp, int type, int error,
1.64      pooka     203:        const char *str, puffs_cookie_t ck)
1.58      pooka     204: {
                    205:        struct puffs_msgpark *park;
                    206:        struct puffs_error *perr;
                    207:
1.63      pooka     208:        puffs_msgmem_alloc(sizeof(struct puffs_error), &park, (void *)&perr, 1);
1.58      pooka     209:        puffs_msg_setfaf(park);
1.64      pooka     210:        puffs_msg_setinfo(park, PUFFSOP_ERROR, type, ck);
1.58      pooka     211:
                    212:        perr->perr_error = error;
                    213:        strlcpy(perr->perr_str, str, sizeof(perr->perr_str));
                    214:
                    215:        puffs_msg_enqueue(pmp, park);
                    216:        puffs_msgmem_release(park);
                    217: }

CVSweb <webmaster@jp.NetBSD.org>