The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/fs/nwfs/nwfs_vnops.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1999, 2000, 2001 Boris Popov
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  * $FreeBSD$
   27  */
   28 #include <sys/param.h>
   29 #include <sys/systm.h>
   30 #include <sys/namei.h>
   31 #include <sys/kernel.h>
   32 #include <sys/bio.h>
   33 #include <sys/buf.h>
   34 #include <sys/fcntl.h>
   35 #include <sys/mount.h>
   36 #include <sys/unistd.h>
   37 #include <sys/vnode.h>
   38 
   39 #include <vm/vm.h>
   40 #include <vm/vm_extern.h>
   41 
   42 #include <netncp/ncp.h>
   43 #include <netncp/ncp_conn.h>
   44 #include <netncp/ncp_subr.h>
   45 #include <netncp/nwerror.h>
   46 #include <netncp/ncp_nls.h>
   47 
   48 #include <fs/nwfs/nwfs.h>
   49 #include <fs/nwfs/nwfs_node.h>
   50 #include <fs/nwfs/nwfs_subr.h>
   51 
   52 /*
   53  * Prototypes for NWFS vnode operations
   54  */
   55 static vop_create_t     nwfs_create;
   56 static vop_mknod_t      nwfs_mknod;
   57 static vop_open_t       nwfs_open;
   58 static vop_close_t      nwfs_close;
   59 static vop_access_t     nwfs_access;
   60 static vop_getattr_t    nwfs_getattr;
   61 static vop_setattr_t    nwfs_setattr;
   62 static vop_read_t       nwfs_read;
   63 static vop_write_t      nwfs_write;
   64 static vop_fsync_t      nwfs_fsync;
   65 static vop_remove_t     nwfs_remove;
   66 static vop_link_t       nwfs_link;
   67 static vop_lookup_t     nwfs_lookup;
   68 static vop_rename_t     nwfs_rename;
   69 static vop_mkdir_t      nwfs_mkdir;
   70 static vop_rmdir_t      nwfs_rmdir;
   71 static vop_symlink_t    nwfs_symlink;
   72 static vop_readdir_t    nwfs_readdir;
   73 static vop_strategy_t   nwfs_strategy;
   74 static vop_print_t      nwfs_print;
   75 static vop_pathconf_t   nwfs_pathconf;
   76 
   77 /* Global vfs data structures for nwfs */
   78 struct vop_vector nwfs_vnodeops = {
   79         .vop_default =          &default_vnodeops,
   80 
   81         .vop_access =           nwfs_access,
   82         .vop_close =            nwfs_close,
   83         .vop_create =           nwfs_create,
   84         .vop_fsync =            nwfs_fsync,
   85         .vop_getattr =          nwfs_getattr,
   86         .vop_getpages =         nwfs_getpages,
   87         .vop_inactive =         nwfs_inactive,
   88         .vop_ioctl =            nwfs_ioctl,
   89         .vop_link =             nwfs_link,
   90         .vop_lookup =           nwfs_lookup,
   91         .vop_mkdir =            nwfs_mkdir,
   92         .vop_mknod =            nwfs_mknod,
   93         .vop_open =             nwfs_open,
   94         .vop_pathconf =         nwfs_pathconf,
   95         .vop_print =            nwfs_print,
   96         .vop_putpages =         nwfs_putpages,
   97         .vop_read =             nwfs_read,
   98         .vop_readdir =          nwfs_readdir,
   99         .vop_reclaim =          nwfs_reclaim,
  100         .vop_remove =           nwfs_remove,
  101         .vop_rename =           nwfs_rename,
  102         .vop_rmdir =            nwfs_rmdir,
  103         .vop_setattr =          nwfs_setattr,
  104         .vop_strategy =         nwfs_strategy,
  105         .vop_symlink =          nwfs_symlink,
  106         .vop_write =            nwfs_write,
  107 };
  108 
  109 /*
  110  * nwfs_access vnode op
  111  */
  112 static int
  113 nwfs_access(ap)
  114         struct vop_access_args /* {
  115                 struct vnode *a_vp;
  116                 accmode_t a_accmode;
  117                 struct ucred *a_cred;
  118                 struct thread *td;
  119         } */ *ap;
  120 {
  121         struct vnode *vp = ap->a_vp;
  122         mode_t mpmode;
  123         struct nwmount *nmp = VTONWFS(vp);
  124 
  125         NCPVNDEBUG("\n");
  126         if ((ap->a_accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
  127                 switch (vp->v_type) {
  128                     case VREG: case VDIR: case VLNK:
  129                         return (EROFS);
  130                     default:
  131                         break;
  132                 }
  133         }
  134         mpmode = vp->v_type == VREG ? nmp->m.file_mode :
  135             nmp->m.dir_mode;
  136         return (vaccess(vp->v_type, mpmode, nmp->m.uid,
  137             nmp->m.gid, ap->a_accmode, ap->a_cred, NULL));
  138 }
  139 /*
  140  * nwfs_open vnode op
  141  */
  142 /* ARGSUSED */
  143 static int
  144 nwfs_open(ap)
  145         struct vop_open_args /* {
  146                 struct vnode *a_vp;
  147                 int  a_mode;
  148                 struct ucred *a_cred;
  149                 struct thread *td;
  150         } */ *ap;
  151 {
  152         struct vnode *vp = ap->a_vp;
  153         int mode = ap->a_mode;
  154         struct nwnode *np = VTONW(vp);
  155         struct ncp_open_info no;
  156         struct nwmount *nmp = VTONWFS(vp);
  157         struct vattr vattr;
  158         int error, nwm;
  159 
  160         NCPVNDEBUG("%s,%d\n", np->n_name, np->opened);
  161         if (vp->v_type != VREG && vp->v_type != VDIR) { 
  162                 NCPFATAL("open vtype = %d\n", vp->v_type);
  163                 return (EACCES);
  164         }
  165         if (vp->v_type == VDIR) return 0;       /* nothing to do now */
  166         if (np->n_flag & NMODIFIED) {
  167                 if ((error = nwfs_vinvalbuf(vp, ap->a_td)) == EINTR)
  168                         return (error);
  169                 np->n_atime = 0;
  170                 error = VOP_GETATTR(vp, &vattr, ap->a_cred);
  171                 if (error) return (error);
  172                 np->n_mtime = vattr.va_mtime.tv_sec;
  173         } else {
  174                 error = VOP_GETATTR(vp, &vattr, ap->a_cred);
  175                 if (error) return (error);
  176                 if (np->n_mtime != vattr.va_mtime.tv_sec) {
  177                         if ((error = nwfs_vinvalbuf(vp, ap->a_td)) == EINTR)
  178                                 return (error);
  179                         np->n_mtime = vattr.va_mtime.tv_sec;
  180                 }
  181         }
  182         if (np->opened) {
  183                 np->opened++;
  184                 return 0;
  185         }
  186         nwm = AR_READ;
  187         if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
  188                 nwm |= AR_WRITE;
  189         error = ncp_open_create_file_or_subdir(nmp, vp, 0, NULL, OC_MODE_OPEN,
  190                                                0, nwm, &no, ap->a_td, ap->a_cred);
  191         if (error) {
  192                 if (mode & FWRITE)
  193                         return EACCES;
  194                 nwm = AR_READ;
  195                 error = ncp_open_create_file_or_subdir(nmp, vp, 0, NULL, OC_MODE_OPEN, 0,
  196                                                    nwm, &no, ap->a_td, ap->a_cred);
  197         }
  198         if (!error) {
  199                 np->opened++;
  200                 np->n_fh = no.fh;
  201                 np->n_origfh = no.origfh;
  202         }
  203         np->n_atime = 0;
  204         return (error);
  205 }
  206 
  207 static int
  208 nwfs_close(ap)
  209         struct vop_close_args /* {
  210                 struct vnodeop_desc *a_desc;
  211                 struct vnode *a_vp;
  212                 int  a_fflag;
  213                 struct ucred *a_cred;
  214                 struct thread *td;
  215         } */ *ap;
  216 {
  217         struct vnode *vp = ap->a_vp;
  218         struct nwnode *np = VTONW(vp);
  219         int error;
  220 
  221         NCPVNDEBUG("name=%s,pid=%d,c=%d\n", np->n_name, ap->a_td->td_proc->p_pid,
  222                         np->opened);
  223 
  224         if (vp->v_type == VDIR) return 0;       /* nothing to do now */
  225         error = 0;
  226         VI_LOCK(vp);
  227         if (np->opened == 0) {
  228                 VI_UNLOCK(vp);
  229                 return 0;
  230         }
  231         VI_UNLOCK(vp);
  232         error = nwfs_vinvalbuf(vp, ap->a_td);
  233         VI_LOCK(vp);
  234         if (np->opened == 0) {
  235                 VI_UNLOCK(vp);
  236                 return 0;
  237         }
  238         if (--np->opened == 0) {
  239                 VI_UNLOCK(vp);
  240                 error = ncp_close_file(NWFSTOCONN(VTONWFS(vp)), &np->n_fh, 
  241                    ap->a_td, ap->a_cred);
  242         } else
  243                 VI_UNLOCK(vp);
  244         np->n_atime = 0;
  245         return (error);
  246 }
  247 
  248 /*
  249  * nwfs_getattr call from vfs.
  250  */
  251 static int
  252 nwfs_getattr(ap)
  253         struct vop_getattr_args /* {
  254                 struct vnode *a_vp;
  255                 struct vattr *a_vap;
  256                 struct ucred *a_cred;
  257         } */ *ap;
  258 {
  259         struct vnode *vp = ap->a_vp;
  260         struct nwnode *np = VTONW(vp);
  261         struct vattr *va=ap->a_vap;
  262         struct nwmount *nmp = VTONWFS(vp);
  263         struct thread *td = curthread;
  264         struct nw_entry_info fattr;
  265         int error;
  266         u_int32_t oldsize;
  267 
  268         NCPVNDEBUG("%lx:%d: '%s' %d\n", (long)vp, nmp->n_volume, np->n_name, (vp->v_vflag & VV_ROOT) != 0);
  269         error = nwfs_attr_cachelookup(vp, va);
  270         if (!error) return 0;
  271         NCPVNDEBUG("not in cache\n");
  272         oldsize = np->n_size;
  273         if (np->n_flag & NVOLUME) {
  274                 error = ncp_obtain_info(nmp, np->n_fid.f_id, 0, NULL, &fattr,
  275                     td, ap->a_cred);
  276         } else {
  277                 error = ncp_obtain_info(nmp, np->n_fid.f_parent, np->n_nmlen, 
  278                     np->n_name, &fattr, td, ap->a_cred);
  279         }
  280         if (error) {
  281                 NCPVNDEBUG("error %d\n", error);
  282                 return error;
  283         }
  284         nwfs_attr_cacheenter(vp, &fattr);
  285         *va = np->n_vattr;
  286         if (np->opened)
  287                 np->n_size = oldsize;
  288         return (0);
  289 }
  290 /*
  291  * nwfs_setattr call from vfs.
  292  */
  293 static int
  294 nwfs_setattr(ap)
  295         struct vop_setattr_args /* {
  296                 struct vnode *a_vp;
  297                 struct vattr *a_vap;
  298                 struct ucred *a_cred;
  299         } */ *ap;
  300 {
  301         struct vnode *vp = ap->a_vp;
  302         struct nwnode *np = VTONW(vp);
  303         struct vattr *vap = ap->a_vap;
  304         u_quad_t tsize=0;
  305         int error = 0;
  306 
  307         NCPVNDEBUG("\n");
  308         if (vap->va_flags != VNOVAL)
  309                 return (EOPNOTSUPP);
  310         /*
  311          * Disallow write attempts if the filesystem is mounted read-only.
  312          */
  313         if ((vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL || 
  314              vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL ||
  315              vap->va_mode != (mode_t)VNOVAL) &&(vp->v_mount->mnt_flag & MNT_RDONLY))
  316                 return (EROFS);
  317         if (vap->va_size != VNOVAL) {
  318                 switch (vp->v_type) {
  319                 case VDIR:
  320                         return (EISDIR);
  321                 case VREG:
  322                         /*
  323                          * Disallow write attempts if the filesystem is
  324                          * mounted read-only.
  325                          */
  326                         if (vp->v_mount->mnt_flag & MNT_RDONLY)
  327                                 return (EROFS);
  328                         vnode_pager_setsize(vp, (u_long)vap->va_size);
  329                         tsize = np->n_size;
  330                         np->n_size = vap->va_size;
  331                         break;
  332                 default:
  333                         return EINVAL;
  334                 };
  335         }
  336         error = ncp_setattr(vp, vap, ap->a_cred, curthread);
  337         if (error && vap->va_size != VNOVAL) {
  338                 np->n_size = tsize;
  339                 vnode_pager_setsize(vp, (u_long)tsize);
  340         }
  341         np->n_atime = 0;        /* invalidate cache */
  342         VOP_GETATTR(vp, vap, ap->a_cred);
  343         np->n_mtime = vap->va_mtime.tv_sec;
  344         return (0);
  345 }
  346 /*
  347  * nwfs_read call.
  348  */
  349 static int
  350 nwfs_read(ap)
  351         struct vop_read_args /* {
  352                 struct vnode *a_vp;
  353                 struct uio *a_uio;
  354                 int  a_ioflag;
  355                 struct ucred *a_cred;
  356         } */ *ap;
  357 {
  358         struct vnode *vp = ap->a_vp;
  359         struct uio *uio=ap->a_uio;
  360         int error;
  361         NCPVNDEBUG("nwfs_read:\n");
  362 
  363         if (vp->v_type != VREG && vp->v_type != VDIR)
  364                 return (EPERM);
  365         error = nwfs_readvnode(vp, uio, ap->a_cred);
  366         return error;
  367 }
  368 
  369 static int
  370 nwfs_write(ap)
  371         struct vop_write_args /* {
  372                 struct vnode *a_vp;
  373                 struct uio *a_uio;
  374                 int  a_ioflag;
  375                 struct ucred *a_cred;
  376         } */ *ap;
  377 {
  378         struct vnode *vp = ap->a_vp;
  379         struct uio *uio = ap->a_uio;
  380         int error;
  381 
  382         NCPVNDEBUG("%d,ofs=%d,sz=%d\n", vp->v_type, (int)uio->uio_offset, uio->uio_resid);
  383 
  384         if (vp->v_type != VREG)
  385                 return (EPERM);
  386         error = nwfs_writevnode(vp, uio, ap->a_cred, ap->a_ioflag);
  387         return(error);
  388 }
  389 /*
  390  * nwfs_create call
  391  * Create a regular file. On entry the directory to contain the file being
  392  * created is locked.  We must release before we return. We must also free
  393  * the pathname buffer pointed at by cnp->cn_pnbuf, always on error, or
  394  * only if the SAVESTART bit in cn_flags is clear on success.
  395  */
  396 static int
  397 nwfs_create(ap)
  398         struct vop_create_args /* {
  399                 struct vnode *a_dvp;
  400                 struct vnode **a_vpp;
  401                 struct componentname *a_cnp;
  402                 struct vattr *a_vap;
  403         } */ *ap;
  404 {
  405         struct vnode *dvp = ap->a_dvp;
  406         struct vattr *vap = ap->a_vap;
  407         struct vnode **vpp=ap->a_vpp;
  408         struct componentname *cnp = ap->a_cnp;
  409         struct vnode *vp = (struct vnode *)0;
  410         int error = 0, fmode;
  411         struct vattr vattr;
  412         struct nwnode *np;
  413         struct ncp_open_info no;
  414         struct nwmount *nmp=VTONWFS(dvp);
  415         ncpfid fid;
  416         
  417 
  418         NCPVNDEBUG("\n");
  419         *vpp = NULL;
  420         if (vap->va_type == VSOCK)
  421                 return (EOPNOTSUPP);
  422         if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)))
  423                 return (error);
  424         fmode = AR_READ | AR_WRITE;
  425 /*      if (vap->va_vaflags & VA_EXCLUSIVE)
  426                 fmode |= AR_DENY_READ | AR_DENY_WRITE;*/
  427         
  428         error = ncp_open_create_file_or_subdir(nmp, dvp, cnp->cn_namelen, cnp->cn_nameptr, 
  429                            OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE,
  430                            0, fmode, &no, cnp->cn_thread, cnp->cn_cred);
  431         if (!error) {
  432                 error = ncp_close_file(NWFSTOCONN(nmp), &no.fh, cnp->cn_thread, cnp->cn_cred);
  433                 fid.f_parent = VTONW(dvp)->n_fid.f_id;
  434                 fid.f_id = no.fattr.dirEntNum;
  435                 error = nwfs_nget(VTOVFS(dvp), fid, &no.fattr, dvp, &vp);
  436                 if (!error) {
  437                         np = VTONW(vp);
  438                         np->opened = 0;
  439                         *vpp = vp;
  440                 }
  441                 if (cnp->cn_flags & MAKEENTRY)
  442                         cache_enter(dvp, vp, cnp);
  443         }
  444         return (error);
  445 }
  446 
  447 /*
  448  * nwfs_remove call. It isn't possible to emulate UFS behaivour because
  449  * NetWare doesn't allow delete/rename operations on an opened file.
  450  */
  451 static int
  452 nwfs_remove(ap)
  453         struct vop_remove_args /* {
  454                 struct vnodeop_desc *a_desc;
  455                 struct vnode * a_dvp;
  456                 struct vnode * a_vp;
  457                 struct componentname * a_cnp;
  458         } */ *ap;
  459 {
  460         struct vnode *vp = ap->a_vp;
  461         struct vnode *dvp = ap->a_dvp;
  462         struct componentname *cnp = ap->a_cnp;
  463         struct nwnode *np = VTONW(vp);
  464         struct nwmount *nmp = VTONWFS(vp);
  465         int error;
  466 
  467         if (vp->v_type == VDIR || np->opened || vrefcnt(vp) != 1)
  468                 return EPERM;
  469         cache_purge(vp);
  470         error = ncp_DeleteNSEntry(nmp, VTONW(dvp)->n_fid.f_id,
  471             cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_thread, cnp->cn_cred);
  472         if (error == 0)
  473                 np->n_flag |= NSHOULDFREE;
  474         else if (error == 0x899c)
  475                 error = EACCES;
  476         return (error);
  477 }
  478 
  479 /*
  480  * nwfs_file rename call
  481  */
  482 static int
  483 nwfs_rename(ap)
  484         struct vop_rename_args  /* {
  485                 struct vnode *a_fdvp;
  486                 struct vnode *a_fvp;
  487                 struct componentname *a_fcnp;
  488                 struct vnode *a_tdvp;
  489                 struct vnode *a_tvp;
  490                 struct componentname *a_tcnp;
  491         } */ *ap;
  492 {
  493         struct vnode *fvp = ap->a_fvp;
  494         struct vnode *tvp = ap->a_tvp;
  495         struct vnode *fdvp = ap->a_fdvp;
  496         struct vnode *tdvp = ap->a_tdvp;
  497         struct componentname *tcnp = ap->a_tcnp;
  498         struct componentname *fcnp = ap->a_fcnp;
  499         struct nwmount *nmp=VTONWFS(fvp);
  500         u_int16_t oldtype = 6;
  501         int error=0;
  502 
  503         /* Check for cross-device rename */
  504         if ((fvp->v_mount != tdvp->v_mount) ||
  505             (tvp && (fvp->v_mount != tvp->v_mount))) {
  506                 error = EXDEV;
  507                 goto out;
  508         }
  509 
  510         if (tvp && vrefcnt(tvp) > 1) {
  511                 error = EBUSY;
  512                 goto out;
  513         }
  514         if (fvp->v_type == VDIR) {
  515                 oldtype |= NW_TYPE_SUBDIR;
  516         } else if (fvp->v_type == VREG) {
  517                 oldtype |= NW_TYPE_FILE;
  518         } else {
  519                 error = EINVAL;
  520                 goto out;
  521         }
  522         if (tvp && tvp != fvp) {
  523                 error = ncp_DeleteNSEntry(nmp, VTONW(tdvp)->n_fid.f_id,
  524                     tcnp->cn_namelen, tcnp->cn_nameptr, 
  525                     tcnp->cn_thread, tcnp->cn_cred);
  526                 if (error == 0x899c) error = EACCES;
  527                 if (error)
  528                         goto out_cacherem;
  529         }
  530         error = ncp_nsrename(NWFSTOCONN(nmp), nmp->n_volume, nmp->name_space, 
  531                 oldtype, &nmp->m.nls,
  532                 VTONW(fdvp)->n_fid.f_id, fcnp->cn_nameptr, fcnp->cn_namelen,
  533                 VTONW(tdvp)->n_fid.f_id, tcnp->cn_nameptr, tcnp->cn_namelen,
  534                 tcnp->cn_thread, tcnp->cn_cred);
  535 
  536         if (error == 0x8992)
  537                 error = EEXIST;
  538         if (fvp->v_type == VDIR) {
  539                 if (tvp != NULL && tvp->v_type == VDIR)
  540                         cache_purge(tdvp);
  541                 cache_purge(fdvp);
  542         }
  543 out_cacherem:
  544         nwfs_attr_cacheremove(fdvp);
  545         nwfs_attr_cacheremove(tdvp);
  546         nwfs_attr_cacheremove(fvp);
  547 out:
  548         if (tdvp == tvp)
  549                 vrele(tdvp);
  550         else
  551                 vput(tdvp);
  552         if (tvp)
  553                 vput(tvp);
  554         vrele(fdvp);
  555         vrele(fvp);
  556         if (tvp)
  557                 nwfs_attr_cacheremove(tvp);
  558         /*
  559          * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
  560          */
  561         if (error == ENOENT)
  562                 error = 0;
  563         return (error);
  564 }
  565 
  566 /*
  567  * nwfs hard link create call
  568  * Netware filesystems don't know what links are.
  569  */
  570 static int
  571 nwfs_link(ap)
  572         struct vop_link_args /* {
  573                 struct vnode *a_tdvp;
  574                 struct vnode *a_vp;
  575                 struct componentname *a_cnp;
  576         } */ *ap;
  577 {
  578         return EOPNOTSUPP;
  579 }
  580 
  581 /*
  582  * nwfs_symlink link create call
  583  * Netware filesystems don't know what symlinks are.
  584  */
  585 static int
  586 nwfs_symlink(ap)
  587         struct vop_symlink_args /* {
  588                 struct vnode *a_dvp;
  589                 struct vnode **a_vpp;
  590                 struct componentname *a_cnp;
  591                 struct vattr *a_vap;
  592                 char *a_target;
  593         } */ *ap;
  594 {
  595         return (EOPNOTSUPP);
  596 }
  597 
  598 static int nwfs_mknod(ap) 
  599         struct vop_mknod_args /* {
  600         } */ *ap;
  601 {
  602         return (EOPNOTSUPP);
  603 }
  604 
  605 /*
  606  * nwfs_mkdir call
  607  */
  608 static int
  609 nwfs_mkdir(ap)
  610         struct vop_mkdir_args /* {
  611                 struct vnode *a_dvp;
  612                 struct vnode **a_vpp;
  613                 struct componentname *a_cnp;
  614                 struct vattr *a_vap;
  615         } */ *ap;
  616 {
  617         struct vnode *dvp = ap->a_dvp;
  618 /*      struct vattr *vap = ap->a_vap;*/
  619         struct componentname *cnp = ap->a_cnp;
  620         int len=cnp->cn_namelen;
  621         struct ncp_open_info no;
  622         struct vnode *newvp = (struct vnode *)0;
  623         ncpfid fid;
  624         int error = 0;
  625         struct vattr vattr;
  626         char *name=cnp->cn_nameptr;
  627 
  628         if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred)))
  629                 return (error);
  630         if ((name[0] == '.') && ((len == 1) || ((len == 2) && (name[1] == '.')))) {
  631                 return EEXIST;
  632         }
  633         if (ncp_open_create_file_or_subdir(VTONWFS(dvp), dvp, cnp->cn_namelen,
  634                         cnp->cn_nameptr, OC_MODE_CREATE, aDIR, 0xffff,
  635                         &no, cnp->cn_thread, cnp->cn_cred) != 0) {
  636                 error = EACCES;
  637         } else {
  638                 error = 0;
  639         }
  640         if (!error) {
  641                 fid.f_parent = VTONW(dvp)->n_fid.f_id;
  642                 fid.f_id = no.fattr.dirEntNum;
  643                 error = nwfs_nget(VTOVFS(dvp), fid, &no.fattr, dvp, &newvp);
  644                 if (!error) {
  645                         newvp->v_type = VDIR;
  646                         *ap->a_vpp = newvp;
  647                 }
  648         }
  649         return (error);
  650 }
  651 
  652 /*
  653  * nwfs_remove directory call
  654  */
  655 static int
  656 nwfs_rmdir(ap)
  657         struct vop_rmdir_args /* {
  658                 struct vnode *a_dvp;
  659                 struct vnode *a_vp;
  660                 struct componentname *a_cnp;
  661         } */ *ap;
  662 {
  663         struct vnode *vp = ap->a_vp;
  664         struct vnode *dvp = ap->a_dvp;
  665         struct componentname *cnp = ap->a_cnp;
  666         struct nwnode *np = VTONW(vp);
  667         struct nwmount *nmp = VTONWFS(vp);
  668         struct nwnode *dnp = VTONW(dvp);
  669         int error = EIO;
  670 
  671         if (dvp == vp)
  672                 return EINVAL;
  673 
  674         error = ncp_DeleteNSEntry(nmp, dnp->n_fid.f_id, 
  675                 cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_thread, cnp->cn_cred);
  676         if (error == 0)
  677                 np->n_flag |= NSHOULDFREE;
  678         else if (error == NWE_DIR_NOT_EMPTY)
  679                 error = ENOTEMPTY;
  680         dnp->n_flag |= NMODIFIED;
  681         nwfs_attr_cacheremove(dvp);
  682         cache_purge(dvp);
  683         cache_purge(vp);
  684         return (error);
  685 }
  686 
  687 /*
  688  * nwfs_readdir call
  689  */
  690 static int
  691 nwfs_readdir(ap)
  692         struct vop_readdir_args /* {
  693                 struct vnode *a_vp;
  694                 struct uio *a_uio;
  695                 struct ucred *a_cred;
  696                 int *a_eofflag;
  697                 u_long *a_cookies;
  698                 int a_ncookies;
  699         } */ *ap;
  700 {
  701         struct vnode *vp = ap->a_vp;
  702         struct uio *uio = ap->a_uio;
  703         int error;
  704 
  705         if (vp->v_type != VDIR)
  706                 return (EPERM);
  707         if (ap->a_ncookies) {
  708                 printf("nwfs_readdir: no support for cookies now...");
  709                 return (EOPNOTSUPP);
  710         }
  711 
  712         error = nwfs_readvnode(vp, uio, ap->a_cred);
  713         return error;
  714 }
  715 /* ARGSUSED */
  716 static int
  717 nwfs_fsync(ap)
  718         struct vop_fsync_args /* {
  719                 struct vnodeop_desc *a_desc;
  720                 struct vnode * a_vp;
  721                 struct ucred * a_cred;
  722                 int  a_waitfor;
  723                 struct thread *a_td;
  724         } */ *ap;
  725 {
  726 /*      return (nfs_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td, 1));*/
  727     return (0);
  728 }
  729 
  730 /* ARGSUSED */
  731 static 
  732 int nwfs_print (ap) 
  733         struct vop_print_args /* {
  734                 struct vnode *a_vp;
  735         } */ *ap;
  736 {
  737         struct vnode *vp = ap->a_vp;
  738         struct nwnode *np = VTONW(vp);
  739 
  740         printf("\tnwfs node: name = '%s', fid = %d, pfid = %d\n",
  741             np->n_name, np->n_fid.f_id, np->n_fid.f_parent);
  742         return (0);
  743 }
  744 
  745 static int nwfs_pathconf (ap)
  746         struct vop_pathconf_args  /* {
  747         struct vnode *vp;
  748         int name;
  749         register_t *retval;
  750         } */ *ap;
  751 {
  752         int name=ap->a_name, error=0;
  753         register_t *retval=ap->a_retval;
  754         
  755         switch(name){
  756                 case _PC_LINK_MAX:
  757                         *retval=0;
  758                         break;
  759                 case _PC_NAME_MAX:
  760                         *retval=NCP_MAX_FILENAME; /* XXX from nwfsnode */
  761                         break;
  762                 case _PC_PATH_MAX:
  763                         *retval=NCP_MAXPATHLEN; /* XXX from nwfsnode */
  764                         break;
  765                 default:
  766                         error=EINVAL;
  767         }
  768         return(error);
  769 }
  770 
  771 static int nwfs_strategy (ap) 
  772         struct vop_strategy_args /* {
  773         struct buf *a_bp
  774         } */ *ap;
  775 {
  776         struct buf *bp=ap->a_bp;
  777         struct ucred *cr;
  778         struct thread *td;
  779 
  780         NCPVNDEBUG("\n");
  781         if (bp->b_flags & B_ASYNC)
  782                 td = (struct thread *)0;
  783         else
  784                 td = curthread; /* XXX */
  785         if (bp->b_iocmd == BIO_READ)
  786                 cr = bp->b_rcred;
  787         else
  788                 cr = bp->b_wcred;
  789         /*
  790          * If the op is asynchronous and an i/o daemon is waiting
  791          * queue the request, wake it up and wait for completion
  792          * otherwise just do it ourselves.
  793          */
  794         if ((bp->b_flags & B_ASYNC) == 0 )
  795                 (void)nwfs_doio(ap->a_vp, bp, cr, td);
  796         return (0);
  797 }
  798 
  799 
  800 /*
  801  * How to keep the brain busy ...
  802  * Currently lookup routine can make two lookup for vnode. This can be
  803  * avoided by reorg the code.
  804  */
  805 int
  806 nwfs_lookup(ap)
  807         struct vop_lookup_args /* {
  808                 struct vnodeop_desc *a_desc;
  809                 struct vnode *a_dvp;
  810                 struct vnode **a_vpp;
  811                 struct componentname *a_cnp;
  812         } */ *ap;
  813 {
  814         struct componentname *cnp = ap->a_cnp;
  815         struct vnode *dvp = ap->a_dvp;
  816         struct vnode **vpp = ap->a_vpp;
  817         int flags = cnp->cn_flags;
  818         struct vnode *vp;
  819         struct nwmount *nmp;
  820         struct mount *mp = dvp->v_mount;
  821         struct nwnode *dnp, *npp;
  822         struct nw_entry_info fattr, *fap;
  823         ncpfid fid;
  824         int nameiop=cnp->cn_nameiop, islastcn;
  825         int error = 0, notfound;
  826         struct thread *td = cnp->cn_thread;
  827         char _name[cnp->cn_namelen+1];
  828         bcopy(cnp->cn_nameptr, _name, cnp->cn_namelen);
  829         _name[cnp->cn_namelen]=0;
  830         
  831         if (dvp->v_type != VDIR)
  832                 return (ENOTDIR);
  833         if ((flags & ISDOTDOT) && (dvp->v_vflag & VV_ROOT)) {
  834                 printf("nwfs_lookup: invalid '..'\n");
  835                 return EIO;
  836         }
  837 
  838         NCPVNDEBUG("%d '%s' in '%s' id=d\n", nameiop, _name, 
  839                 VTONW(dvp)->n_name/*, VTONW(dvp)->n_name*/);
  840 
  841         islastcn = flags & ISLASTCN;
  842         if (islastcn && (mp->mnt_flag & MNT_RDONLY) && (nameiop != LOOKUP))
  843                 return (EROFS);
  844         if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td)))
  845                 return (error);
  846         nmp = VFSTONWFS(mp);
  847         dnp = VTONW(dvp);
  848 /*
  849 printf("dvp %d:%d:%d\n", (int)mp, (int)dvp->v_vflag & VV_ROOT, (int)flags & ISDOTDOT);
  850 */
  851         error = ncp_pathcheck(cnp->cn_nameptr, cnp->cn_namelen, &nmp->m.nls, 
  852             (nameiop == CREATE || nameiop == RENAME) && (nmp->m.nls.opt & NWHP_NOSTRICT) == 0);
  853         if (error) 
  854             return ENOENT;
  855 
  856         error = cache_lookup(dvp, vpp, cnp);
  857         NCPVNDEBUG("cache_lookup returned %d\n", error);
  858         if (error > 0)
  859                 return error;
  860         if (error) {            /* name was found */
  861                 struct vattr vattr;
  862 
  863                 vp = *vpp;
  864                 if (!VOP_GETATTR(vp, &vattr, cnp->cn_cred) &&
  865                     vattr.va_ctime.tv_sec == VTONW(vp)->n_ctime) {
  866                         if (nameiop != LOOKUP && islastcn)
  867                                 cnp->cn_flags |= SAVENAME;
  868                         NCPVNDEBUG("use cached vnode");
  869                         return (0);
  870                 }
  871                 cache_purge(vp);
  872                 if (vp != dvp)
  873                         vput(vp);
  874                 else
  875                         vrele(vp);
  876                 *vpp = NULLVP;
  877         }
  878         /* not in cache, so ...  */
  879         error = 0;
  880         *vpp = NULLVP;
  881         fap = NULL;
  882         if (flags & ISDOTDOT) {
  883                 if (NWCMPF(&dnp->n_parent, &nmp->n_rootent)) {
  884                         fid = nmp->n_rootent;
  885                         fap = NULL;
  886                         notfound = 0;
  887                 } else {
  888                         error = nwfs_lookupnp(nmp, dnp->n_parent, td, &npp);
  889                         if (error) {
  890                                 return error;
  891                         }
  892                         fid = dnp->n_parent;
  893                         fap = &fattr;
  894                         /*np = *npp;*/
  895                         notfound = ncp_obtain_info(nmp, npp->n_dosfid,
  896                             0, NULL, fap, td, cnp->cn_cred);
  897                 }
  898         } else {
  899                 fap = &fattr;
  900                 notfound = ncp_lookup(dvp, cnp->cn_namelen, cnp->cn_nameptr,
  901                         fap, td, cnp->cn_cred);
  902                 fid.f_id = fap->dirEntNum;
  903                 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
  904                         fid.f_parent = dnp->n_fid.f_parent;
  905                 } else
  906                         fid.f_parent = dnp->n_fid.f_id;
  907                 NCPVNDEBUG("call to ncp_lookup returned=%d\n", notfound);
  908         }
  909         if (notfound && notfound < 0x80 )
  910                 return (notfound);      /* hard error */
  911         if (notfound) { /* entry not found */
  912                 /* Handle RENAME or CREATE case... */
  913                 if ((nameiop == CREATE || nameiop == RENAME) && islastcn) {
  914                         cnp->cn_flags |= SAVENAME;
  915                         return (EJUSTRETURN);
  916                 }
  917                 return ENOENT;
  918         }/* else {
  919                 NCPVNDEBUG("Found entry %s with id=%d\n", fap->entryName, fap->dirEntNum);
  920         }*/
  921         /* handle DELETE case ... */
  922         if (nameiop == DELETE && islastcn) {    /* delete last component */
  923                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, cnp->cn_thread);
  924                 if (error) return (error);
  925                 if (NWCMPF(&dnp->n_fid, &fid)) {        /* we found ourselfs */
  926                         VREF(dvp);
  927                         *vpp = dvp;
  928                         return 0;
  929                 }
  930                 error = nwfs_nget(mp, fid, fap, dvp, &vp);
  931                 if (error) return (error);
  932                 *vpp = vp;
  933                 cnp->cn_flags |= SAVENAME;      /* I free it later */
  934                 return (0);
  935         }
  936         if (nameiop == RENAME && islastcn) {
  937                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, cnp->cn_thread);
  938                 if (error) return (error);
  939                 if (NWCMPF(&dnp->n_fid, &fid)) return EISDIR;
  940                 error = nwfs_nget(mp, fid, fap, dvp, &vp);
  941                 if (error) return (error);
  942                 *vpp = vp;
  943                 cnp->cn_flags |= SAVENAME;
  944                 return (0);
  945         }
  946         if (flags & ISDOTDOT) {
  947                 VOP_UNLOCK(dvp, 0);             /* race to get the inode */
  948                 error = nwfs_nget(mp, fid, NULL, NULL, &vp);
  949                 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
  950                 if (error)
  951                         return (error);
  952                 *vpp = vp;
  953         } else if (NWCMPF(&dnp->n_fid, &fid)) {
  954                 vref(dvp);
  955                 *vpp = dvp;
  956         } else {
  957                 error = nwfs_nget(mp, fid, fap, dvp, &vp);
  958                 if (error) return (error);
  959                 *vpp = vp;
  960                 NCPVNDEBUG("lookup: getnewvp!\n");
  961         }
  962         if ((cnp->cn_flags & MAKEENTRY)/* && !islastcn*/) {
  963                 VTONW(*vpp)->n_ctime = VTONW(*vpp)->n_vattr.va_ctime.tv_sec;
  964                 cache_enter(dvp, *vpp, cnp);
  965         }
  966         return (0);
  967 }

Cache object: a92b877813cbc60543b709df23795a36


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.