2 * Copyright (c) 2000-2001 Boris Popov
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Boris Popov.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * $FreeBSD: src/sys/fs/smbfs/smbfs_vnops.c,v 1.2.2.8 2003/04/04 08:57:23 tjr Exp $
33 * $DragonFly: src/sys/vfs/smbfs/smbfs_vnops.c,v 1.41 2007/11/20 21:03:50 dillon Exp $
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
40 #include <sys/namei.h>
41 #include <sys/fcntl.h>
42 #include <sys/mount.h>
43 #include <sys/unistd.h>
44 #include <sys/vnode.h>
45 #include <sys/lockf.h>
48 #include <vm/vm_extern.h>
49 #include <vm/vm_zone.h>
52 #include <netproto/smb/smb.h>
53 #include <netproto/smb/smb_conn.h>
54 #include <netproto/smb/smb_subr.h>
57 #include "smbfs_node.h"
58 #include "smbfs_subr.h"
63 * Prototypes for SMBFS vnode operations
65 static int smbfs_create(struct vop_old_create_args
*);
66 static int smbfs_mknod(struct vop_old_mknod_args
*);
67 static int smbfs_open(struct vop_open_args
*);
68 static int smbfs_closel(struct vop_close_args
*);
69 static int smbfs_access(struct vop_access_args
*);
70 static int smbfs_getattr(struct vop_getattr_args
*);
71 static int smbfs_setattr(struct vop_setattr_args
*);
72 static int smbfs_read(struct vop_read_args
*);
73 static int smbfs_write(struct vop_write_args
*);
74 static int smbfs_fsync(struct vop_fsync_args
*);
75 static int smbfs_remove(struct vop_old_remove_args
*);
76 static int smbfs_link(struct vop_old_link_args
*);
77 static int smbfs_lookup(struct vop_old_lookup_args
*);
78 static int smbfs_rename(struct vop_old_rename_args
*);
79 static int smbfs_mkdir(struct vop_old_mkdir_args
*);
80 static int smbfs_rmdir(struct vop_old_rmdir_args
*);
81 static int smbfs_symlink(struct vop_old_symlink_args
*);
82 static int smbfs_readdir(struct vop_readdir_args
*);
83 static int smbfs_bmap(struct vop_bmap_args
*);
84 static int smbfs_strategy(struct vop_strategy_args
*);
85 static int smbfs_print(struct vop_print_args
*);
86 static int smbfs_pathconf(struct vop_pathconf_args
*ap
);
87 static int smbfs_advlock(struct vop_advlock_args
*);
88 static int smbfs_getextattr(struct vop_getextattr_args
*ap
);
90 struct vop_ops smbfs_vnode_vops
= {
91 .vop_default
= vop_defaultop
,
92 .vop_access
= smbfs_access
,
93 .vop_advlock
= smbfs_advlock
,
94 .vop_bmap
= smbfs_bmap
,
95 .vop_close
= smbfs_closel
,
96 .vop_old_create
= smbfs_create
,
97 .vop_fsync
= smbfs_fsync
,
98 .vop_getattr
= smbfs_getattr
,
99 .vop_getpages
= smbfs_getpages
,
100 .vop_inactive
= smbfs_inactive
,
101 .vop_ioctl
= smbfs_ioctl
,
102 .vop_old_link
= smbfs_link
,
103 .vop_old_lookup
= smbfs_lookup
,
104 .vop_old_mkdir
= smbfs_mkdir
,
105 .vop_old_mknod
= smbfs_mknod
,
106 .vop_open
= smbfs_open
,
107 .vop_pathconf
= smbfs_pathconf
,
108 .vop_print
= smbfs_print
,
109 .vop_putpages
= smbfs_putpages
,
110 .vop_read
= smbfs_read
,
111 .vop_readdir
= smbfs_readdir
,
112 .vop_reclaim
= smbfs_reclaim
,
113 .vop_old_remove
= smbfs_remove
,
114 .vop_old_rename
= smbfs_rename
,
115 .vop_old_rmdir
= smbfs_rmdir
,
116 .vop_setattr
= smbfs_setattr
,
117 .vop_strategy
= smbfs_strategy
,
118 .vop_old_symlink
= smbfs_symlink
,
119 .vop_write
= smbfs_write
,
120 .vop_getextattr
= smbfs_getextattr
121 /* .vop_setextattr = smbfs_setextattr */
125 * smbfs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred)
128 smbfs_access(struct vop_access_args
*ap
)
130 struct vnode
*vp
= ap
->a_vp
;
131 struct smbmount
*smp
= VTOSMBFS(vp
);
136 mode
= ((vp
->v_type
== VREG
) ?
137 smp
->sm_args
.file_mode
: smp
->sm_args
.dir_mode
);
138 error
= vop_helper_access(ap
, smp
->sm_args
.uid
, smp
->sm_args
.gid
,
144 * smbfs_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred,
149 smbfs_open(struct vop_open_args
*ap
)
151 struct vnode
*vp
= ap
->a_vp
;
152 struct smbnode
*np
= VTOSMB(vp
);
153 struct smb_cred scred
;
155 int mode
= ap
->a_mode
;
158 SMBVDEBUG("%s,%d\n", np
->n_name
, np
->n_opencount
);
159 if (vp
->v_type
!= VREG
&& vp
->v_type
!= VDIR
) {
160 SMBFSERR("open eacces vtype=%d\n", vp
->v_type
);
163 if (vp
->v_type
== VDIR
) {
164 if (np
->n_opencount
== 0)
165 np
->n_cached_cred
= crhold(ap
->a_cred
);
167 return (vop_stdopen(ap
));
169 if (np
->n_flag
& NMODIFIED
) {
170 if ((error
= smbfs_vinvalbuf(vp
, V_SAVE
, 1)) == EINTR
)
172 smbfs_attr_cacheremove(vp
);
173 error
= VOP_GETATTR(vp
, &vattr
);
176 np
->n_mtime
.tv_sec
= vattr
.va_mtime
.tv_sec
;
178 error
= VOP_GETATTR(vp
, &vattr
);
181 if (np
->n_mtime
.tv_sec
!= vattr
.va_mtime
.tv_sec
) {
182 error
= smbfs_vinvalbuf(vp
, V_SAVE
, 1);
185 np
->n_mtime
.tv_sec
= vattr
.va_mtime
.tv_sec
;
188 if (np
->n_opencount
) {
190 return (vop_stdopen(ap
));
192 accmode
= SMB_AM_OPENREAD
;
193 if ((vp
->v_mount
->mnt_flag
& MNT_RDONLY
) == 0)
194 accmode
= SMB_AM_OPENRW
;
195 smb_makescred(&scred
, curthread
, ap
->a_cred
);
196 error
= smbfs_smb_open(np
, accmode
, &scred
);
200 accmode
= SMB_AM_OPENREAD
;
201 error
= smbfs_smb_open(np
, accmode
, &scred
);
204 np
->n_cached_cred
= crhold(ap
->a_cred
);
207 smbfs_attr_cacheremove(vp
);
214 smbfs_closel(struct vop_close_args
*ap
)
216 struct vnode
*vp
= ap
->a_vp
;
217 struct smbnode
*np
= VTOSMB(vp
);
218 struct smb_cred scred
;
222 SMBVDEBUG("name=%s, pid=%d, c=%d\n",np
->n_name
, p
->p_pid
, np
->n_opencount
);
224 smb_makescred(&scred
, curthread
, proc0
.p_ucred
);
227 if (np
->n_opencount
== 0) {
228 if (vp
->v_type
!= VDIR
)
229 SMBERROR("Negative opencount\n");
233 if (vp
->v_type
== VDIR
) {
237 smbfs_findclose(np
->n_dirseq
, &scred
);
241 error
= smbfs_vinvalbuf(vp
, V_SAVE
, 1);
244 VOP_GETATTR(vp
, &vattr
);
245 error
= smbfs_smb_close(np
->n_mount
->sm_share
, np
->n_fid
,
246 &np
->n_mtime
, &scred
);
248 crfree(np
->n_cached_cred
);
249 np
->n_cached_cred
= NULL
;
250 smbfs_attr_cacheremove(vp
);
257 * smbfs_getattr call from vfs.
259 * smbfs_getattr(struct vnode *a_vp, struct vattr *a_vap)
262 smbfs_getattr(struct vop_getattr_args
*ap
)
264 struct vnode
*vp
= ap
->a_vp
;
265 struct smbnode
*np
= VTOSMB(vp
);
266 struct vattr
*va
=ap
->a_vap
;
267 struct smbfattr fattr
;
268 struct smb_cred scred
;
272 SMBVDEBUG("%lx: '%s' %d\n", (long)vp
, np
->n_name
, (vp
->v_flag
& VROOT
) != 0);
273 error
= smbfs_attr_cachelookup(vp
, va
);
276 SMBVDEBUG("not in the cache\n");
277 smb_makescred(&scred
, curthread
, proc0
.p_ucred
);
278 oldsize
= np
->n_size
;
279 error
= smbfs_smb_lookup(np
, NULL
, 0, &fattr
, &scred
);
281 SMBVDEBUG("error %d\n", error
);
284 smbfs_attr_cacheenter(vp
, &fattr
);
285 smbfs_attr_cachelookup(vp
, va
);
287 np
->n_size
= oldsize
;
292 * smbfs_setattr(struct vnode *a_vp, struct vattr *a_vap, struct ucred *a_cred)
295 smbfs_setattr(struct vop_setattr_args
*ap
)
297 struct vnode
*vp
= ap
->a_vp
;
298 struct smbnode
*np
= VTOSMB(vp
);
299 struct vattr
*vap
= ap
->a_vap
;
300 struct timespec
*mtime
, *atime
;
301 struct smb_cred scred
;
302 struct smb_share
*ssp
= np
->n_mount
->sm_share
;
303 struct smb_vc
*vcp
= SSTOVC(ssp
);
305 int isreadonly
, doclose
, error
= 0;
308 if (vap
->va_flags
!= VNOVAL
)
310 isreadonly
= (vp
->v_mount
->mnt_flag
& MNT_RDONLY
);
312 * Disallow write attempts if the filesystem is mounted read-only.
314 if ((vap
->va_uid
!= (uid_t
)VNOVAL
|| vap
->va_gid
!= (gid_t
)VNOVAL
||
315 vap
->va_atime
.tv_sec
!= VNOVAL
|| vap
->va_mtime
.tv_sec
!= VNOVAL
||
316 vap
->va_mode
!= (mode_t
)VNOVAL
) && isreadonly
)
318 smb_makescred(&scred
, curthread
, ap
->a_cred
);
319 if (vap
->va_size
!= VNOVAL
) {
320 switch (vp
->v_type
) {
331 vnode_pager_setsize(vp
, (u_long
)vap
->va_size
);
333 np
->n_size
= vap
->va_size
;
334 if (np
->n_opencount
== 0) {
335 error
= smbfs_smb_open(np
, SMB_AM_OPENRW
, &scred
);
340 error
= smbfs_smb_setfsize(np
, vap
->va_size
, &scred
);
342 smbfs_smb_close(ssp
, np
->n_fid
, NULL
, &scred
);
345 vnode_pager_setsize(vp
, (u_long
)tsize
);
349 mtime
= atime
= NULL
;
350 if (vap
->va_mtime
.tv_sec
!= VNOVAL
)
351 mtime
= &vap
->va_mtime
;
352 if (vap
->va_atime
.tv_sec
!= VNOVAL
)
353 atime
= &vap
->va_atime
;
354 if (mtime
!= atime
) {
355 if (ap
->a_cred
->cr_uid
!= VTOSMBFS(vp
)->sm_args
.uid
&&
356 (error
= priv_check_cred(ap
->a_cred
, PRIV_VFS_SETATTR
, 0)) &&
357 ((vap
->va_vaflags
& VA_UTIMES_NULL
) == 0 ||
358 (error
= VOP_EACCESS(vp
, VWRITE
, ap
->a_cred
))))
362 mtime
= &np
->n_mtime
;
364 atime
= &np
->n_atime
;
367 * If file is opened, then we can use handle based calls.
368 * If not, use path based ones.
370 if (np
->n_opencount
== 0) {
371 if (vcp
->vc_flags
& SMBV_WIN95
) {
372 error
= VOP_OPEN(vp
, FWRITE
, ap
->a_cred
, NULL
);
374 /* error = smbfs_smb_setfattrNT(np, 0, mtime, atime, &scred);
375 VOP_GETATTR(vp, &vattr);*/
377 np
->n_mtime
= *mtime
;
378 VOP_CLOSE(vp
, FWRITE
);
380 } else if ((vcp
->vc_sopt
.sv_caps
& SMB_CAP_NT_SMBS
)) {
381 error
= smbfs_smb_setptime2(np
, mtime
, atime
, 0, &scred
);
382 /* error = smbfs_smb_setpattrNT(np, 0, mtime, atime, &scred);*/
383 } else if (SMB_DIALECT(vcp
) >= SMB_DIALECT_LANMAN2_0
) {
384 error
= smbfs_smb_setptime2(np
, mtime
, atime
, 0, &scred
);
386 error
= smbfs_smb_setpattr(np
, 0, mtime
, &scred
);
389 if (vcp
->vc_sopt
.sv_caps
& SMB_CAP_NT_SMBS
) {
390 error
= smbfs_smb_setfattrNT(np
, 0, mtime
, atime
, &scred
);
391 } else if (SMB_DIALECT(vcp
) >= SMB_DIALECT_LANMAN1_0
) {
392 error
= smbfs_smb_setftime(np
, mtime
, atime
, &scred
);
395 * I have no idea how to handle this for core
396 * level servers. The possible solution is to
397 * update mtime after file is closed.
399 SMBERROR("can't update times on an opened file\n");
404 * Invalidate attribute cache in case if server doesn't set
405 * required attributes.
407 smbfs_attr_cacheremove(vp
); /* invalidate cache */
408 VOP_GETATTR(vp
, vap
);
409 np
->n_mtime
.tv_sec
= vap
->va_mtime
.tv_sec
;
415 * smbfs_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
416 * struct ucred *a_cred)
419 smbfs_read(struct vop_read_args
*ap
)
421 struct vnode
*vp
= ap
->a_vp
;
422 struct uio
*uio
= ap
->a_uio
;
425 if (vp
->v_type
!= VREG
&& vp
->v_type
!= VDIR
)
427 return smbfs_readvnode(vp
, uio
, ap
->a_cred
);
431 * smbfs_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
432 * struct ucred *a_cred)
435 smbfs_write(struct vop_write_args
*ap
)
437 struct vnode
*vp
= ap
->a_vp
;
438 struct uio
*uio
= ap
->a_uio
;
440 SMBVDEBUG("%d,ofs=%d,sz=%d\n",vp
->v_type
, (int)uio
->uio_offset
, uio
->uio_resid
);
441 if (vp
->v_type
!= VREG
)
443 return smbfs_writevnode(vp
, uio
, ap
->a_cred
,ap
->a_ioflag
);
447 * Create a regular file. On entry the directory to contain the file being
448 * created is locked. We must release before we return.
450 * smbfs_create(struct vnode *a_dvp, struct vnode **a_vpp,
451 * struct componentname *a_cnp, struct vattr *a_vap)
454 smbfs_create(struct vop_old_create_args
*ap
)
456 struct vnode
*dvp
= ap
->a_dvp
;
457 struct vattr
*vap
= ap
->a_vap
;
458 struct vnode
**vpp
=ap
->a_vpp
;
459 struct componentname
*cnp
= ap
->a_cnp
;
460 struct smbnode
*dnp
= VTOSMB(dvp
);
463 struct smbfattr fattr
;
464 struct smb_cred scred
;
465 char *name
= cnp
->cn_nameptr
;
466 int nmlen
= cnp
->cn_namelen
;
472 if (vap
->va_type
!= VREG
)
474 if ((error
= VOP_GETATTR(dvp
, &vattr
)))
476 smb_makescred(&scred
, cnp
->cn_td
, cnp
->cn_cred
);
478 error
= smbfs_smb_create(dnp
, name
, nmlen
, &scred
);
481 error
= smbfs_smb_lookup(dnp
, name
, nmlen
, &fattr
, &scred
);
484 error
= smbfs_nget(VTOVFS(dvp
), dvp
, name
, nmlen
, &fattr
, &vp
);
492 * smbfs_remove(struct vnode *a_dvp, struct vnode *a_vp,
493 * struct componentname *a_cnp)
496 smbfs_remove(struct vop_old_remove_args
*ap
)
498 struct vnode
*vp
= ap
->a_vp
;
499 /* struct vnode *dvp = ap->a_dvp;*/
500 struct componentname
*cnp
= ap
->a_cnp
;
501 struct smbnode
*np
= VTOSMB(vp
);
502 struct smb_cred scred
;
505 if (vp
->v_type
== VDIR
|| np
->n_opencount
|| vp
->v_sysref
.refcnt
> 1)
507 smb_makescred(&scred
, cnp
->cn_td
, cnp
->cn_cred
);
508 error
= smbfs_smb_delete(np
, &scred
);
513 * smbfs_file rename call
515 * smbfs_rename(struct vnode *a_fdvp, struct vnode *a_fvp,
516 * struct componentname *a_fcnp, struct vnode *a_tdvp,
517 * struct vnode *a_tvp, struct componentname *a_tcnp)
520 smbfs_rename(struct vop_old_rename_args
*ap
)
522 struct vnode
*fvp
= ap
->a_fvp
;
523 struct vnode
*tvp
= ap
->a_tvp
;
524 struct vnode
*fdvp
= ap
->a_fdvp
;
525 struct vnode
*tdvp
= ap
->a_tdvp
;
526 struct componentname
*tcnp
= ap
->a_tcnp
;
527 /* struct componentname *fcnp = ap->a_fcnp;*/
528 struct smb_cred scred
;
532 /* Check for cross-device rename */
533 if ((fvp
->v_mount
!= tdvp
->v_mount
) ||
534 (tvp
&& (fvp
->v_mount
!= tvp
->v_mount
))) {
539 if (tvp
&& tvp
->v_sysref
.refcnt
> 1) {
543 flags
= 0x10; /* verify all writes */
544 if (fvp
->v_type
== VDIR
) {
546 } else if (fvp
->v_type
== VREG
) {
552 smb_makescred(&scred
, tcnp
->cn_td
, tcnp
->cn_cred
);
554 * It seems that Samba doesn't implement SMB_COM_MOVE call...
557 if (SMB_DIALECT(SSTOCN(smp
->sm_share
)) >= SMB_DIALECT_LANMAN1_0
) {
558 error
= smbfs_smb_move(VTOSMB(fvp
), VTOSMB(tdvp
),
559 tcnp
->cn_nameptr
, tcnp
->cn_namelen
, flags
, &scred
);
564 * We have to do the work atomicaly
566 if (tvp
&& tvp
!= fvp
) {
567 error
= smbfs_smb_delete(VTOSMB(tvp
), &scred
);
571 error
= smbfs_smb_rename(VTOSMB(fvp
), VTOSMB(tdvp
),
572 tcnp
->cn_nameptr
, tcnp
->cn_namelen
, &scred
);
576 smbfs_attr_cacheremove(fdvp
);
577 smbfs_attr_cacheremove(tdvp
);
587 #ifdef possible_mistake
597 * somtime it will come true...
599 * smbfs_link(struct vnode *a_tdvp, struct vnode *a_vp,
600 * struct componentname *a_cnp)
603 smbfs_link(struct vop_old_link_args
*ap
)
609 * smbfs_symlink link create call.
610 * Sometime it will be functional...
612 * smbfs_symlink(struct vnode *a_dvp, struct vnode **a_vpp,
613 * struct componentname *a_cnp, struct vattr *a_vap,
617 smbfs_symlink(struct vop_old_symlink_args
*ap
)
623 smbfs_mknod(struct vop_old_mknod_args
*ap
)
629 * smbfs_mkdir(struct vnode *a_dvp, struct vnode **a_vpp,
630 * struct componentname *a_cnp, struct vattr *a_vap)
633 smbfs_mkdir(struct vop_old_mkdir_args
*ap
)
635 struct vnode
*dvp
= ap
->a_dvp
;
636 /* struct vattr *vap = ap->a_vap;*/
638 struct componentname
*cnp
= ap
->a_cnp
;
639 struct smbnode
*dnp
= VTOSMB(dvp
);
641 struct smb_cred scred
;
642 struct smbfattr fattr
;
643 char *name
= cnp
->cn_nameptr
;
644 int len
= cnp
->cn_namelen
;
647 if ((error
= VOP_GETATTR(dvp
, &vattr
))) {
650 if ((name
[0] == '.') && ((len
== 1) || ((len
== 2) && (name
[1] == '.'))))
652 smb_makescred(&scred
, cnp
->cn_td
, cnp
->cn_cred
);
653 error
= smbfs_smb_mkdir(dnp
, name
, len
, &scred
);
656 error
= smbfs_smb_lookup(dnp
, name
, len
, &fattr
, &scred
);
659 error
= smbfs_nget(VTOVFS(dvp
), dvp
, name
, len
, &fattr
, &vp
);
667 * smbfs_remove directory call
669 * smbfs_rmdir(struct vnode *a_dvp, struct vnode *a_vp,
670 * struct componentname *a_cnp)
673 smbfs_rmdir(struct vop_old_rmdir_args
*ap
)
675 struct vnode
*vp
= ap
->a_vp
;
676 struct vnode
*dvp
= ap
->a_dvp
;
677 struct componentname
*cnp
= ap
->a_cnp
;
678 /* struct smbmount *smp = VTOSMBFS(vp);*/
679 struct smbnode
*dnp
= VTOSMB(dvp
);
680 struct smbnode
*np
= VTOSMB(vp
);
681 struct smb_cred scred
;
687 smb_makescred(&scred
, cnp
->cn_td
, cnp
->cn_cred
);
688 error
= smbfs_smb_rmdir(np
, &scred
);
689 dnp
->n_flag
|= NMODIFIED
;
690 smbfs_attr_cacheremove(dvp
);
697 * smbfs_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred,
698 * int *a_eofflag, off_t *a_cookies, int a_ncookies)
701 smbfs_readdir(struct vop_readdir_args
*ap
)
703 struct vnode
*vp
= ap
->a_vp
;
704 struct uio
*uio
= ap
->a_uio
;
707 if (vp
->v_type
!= VDIR
)
710 if (ap
->a_ncookies
) {
711 kprintf("smbfs_readdir: no support for cookies now...");
715 if ((error
= vn_lock(vp
, LK_EXCLUSIVE
| LK_RETRY
)) == 0) {
716 error
= smbfs_readvnode(vp
, uio
, ap
->a_cred
);
723 * smbfs_fsync(struct vnode *a_vp, int a_waitfor)
727 smbfs_fsync(struct vop_fsync_args
*ap
)
729 /* return (smb_flush(ap->a_vp, ap->a_waitfor, curthread, 1));*/
734 * smbfs_print(struct vnode *a_vp)
737 smbfs_print(struct vop_print_args
*ap
)
739 struct vnode
*vp
= ap
->a_vp
;
740 struct smbnode
*np
= VTOSMB(vp
);
743 kprintf("no smbnode data\n");
746 kprintf("tag VT_SMBFS, name = %s, parent = %p, opencount = %d",
747 np
->n_name
, np
->n_parent
? np
->n_parent
: NULL
,
749 lockmgr_printinfo(&vp
->v_lock
);
755 * smbfs_pathconf(struct vnode *vp, int name, register_t *retval)
758 smbfs_pathconf(struct vop_pathconf_args
*ap
)
760 struct smbmount
*smp
= VFSTOSMBFS(VTOVFS(ap
->a_vp
));
761 struct smb_vc
*vcp
= SSTOVC(smp
->sm_share
);
762 register_t
*retval
= ap
->a_retval
;
765 switch (ap
->a_name
) {
770 *retval
= (vcp
->vc_hflags2
& SMB_FLAGS2_KNOWS_LONG_NAMES
) ? 255 : 12;
773 *retval
= 800; /* XXX: a correct one ? */
782 * smbfs_strategy(struct vnode *a_vp, struct bio *a_bio)
785 smbfs_strategy(struct vop_strategy_args
*ap
)
787 struct bio
*bio
= ap
->a_bio
;
788 struct thread
*td
= NULL
;
792 if (bio
->bio_flags
& BIO_SYNC
)
793 td
= curthread
; /* XXX */
795 if (bio
->bio_flags
& BIO_SYNC
)
796 error
= smbfs_doio(ap
->a_vp
, bio
, proc0
.p_ucred
, td
);
801 * smbfs_bmap(struct vnode *a_vp, off_t a_loffset,
802 * off_t *a_doffsetp, int *a_runp, int *a_runb)
805 smbfs_bmap(struct vop_bmap_args
*ap
)
807 if (ap
->a_doffsetp
!= NULL
)
808 *ap
->a_doffsetp
= ap
->a_loffset
;
809 if (ap
->a_runp
!= NULL
)
811 if (ap
->a_runb
!= NULL
)
817 * smbfs_ioctl(struct vnode *a_vp, u_long a_command, caddr_t a_data,
818 * int fflag, struct ucred *cred, struct proc *p)
821 smbfs_ioctl(struct vop_ioctl_args
*ap
)
826 static char smbfs_atl
[] = "rhsvda";
829 * smbfs_getextattr(struct vnode *a_vp, char *a_name, struct uio *a_uio,
830 * struct ucred *a_cred)
833 smbfs_getextattr(struct vop_getextattr_args
*ap
)
835 struct vnode
*vp
= ap
->a_vp
;
836 struct ucred
*cred
= ap
->a_cred
;
837 struct uio
*uio
= ap
->a_uio
;
838 const char *name
= ap
->a_name
;
839 struct smbnode
*np
= VTOSMB(vp
);
844 error
= VOP_EACCESS(vp
, VREAD
, cred
);
847 error
= VOP_GETATTR(vp
, &vattr
);
850 if (strcmp(name
, "dosattr") == 0) {
851 attr
= np
->n_dosattr
;
852 for (i
= 0; i
< 6; i
++, attr
>>= 1)
853 buf
[i
] = (attr
& 1) ? smbfs_atl
[i
] : '-';
855 error
= uiomove(buf
, i
, uio
);
863 * Since we expected to support F_GETLK (and SMB protocol has no such function),
864 * it is necessary to use lf_advlock(). It would be nice if this function had
865 * a callback mechanism because it will help to improve a level of consistency.
867 * smbfs_advlock(struct vnode *a_vp, caddr_t a_id, int a_op,
868 * struct flock *a_fl, int a_flags)
871 smbfs_advlock(struct vop_advlock_args
*ap
)
873 struct vnode
*vp
= ap
->a_vp
;
874 struct smbnode
*np
= VTOSMB(vp
);
875 struct flock
*fl
= ap
->a_fl
;
876 caddr_t id
= (caddr_t
)1 /* ap->a_id */;
877 /* int flags = ap->a_flags;*/
878 struct thread
*td
= curthread
; /* XXX */
879 struct smb_cred scred
;
880 off_t start
, end
, size
;
883 if (vp
->v_type
== VDIR
) {
885 * SMB protocol have no support for directory locking.
886 * Although locks can be processed on local machine, I don't
887 * think that this is a good idea, because some programs
888 * can work wrong assuming directory is locked. So, we just
889 * return 'operation not supported
894 switch (fl
->l_whence
) {
900 start
= fl
->l_start
+ size
;
909 end
= start
+ fl
->l_len
- 1;
913 smb_makescred(&scred
, td
, td
->td_proc
? td
->td_proc
->p_ucred
: NULL
);
916 switch (fl
->l_type
) {
918 lkop
= SMB_LOCK_EXCL
;
921 lkop
= SMB_LOCK_SHARED
;
924 lkop
= SMB_LOCK_RELEASE
;
929 error
= lf_advlock(ap
, &np
->n_lockf
, size
);
932 lkop
= SMB_LOCK_EXCL
;
933 error
= smbfs_smb_lock(np
, lkop
, id
, start
, end
, &scred
);
936 lf_advlock(ap
, &np
->n_lockf
, size
);
940 lf_advlock(ap
, &np
->n_lockf
, size
);
941 error
= smbfs_smb_lock(np
, SMB_LOCK_RELEASE
, id
, start
, end
, &scred
);
944 error
= lf_advlock(ap
, &np
->n_lockf
, size
);
953 smbfs_pathcheck(struct smbmount
*smp
, const char *name
, int nmlen
, int nameiop
)
955 static const char *badchars
= "*/:<>;?";
956 static const char *badchars83
= " +|,";
961 * Backslash characters, being a path delimiter, are prohibited
962 * within a path component even for LOOKUP operations.
964 if (index(name
, '\\') != NULL
)
967 if (nameiop
== NAMEI_LOOKUP
)
970 if (SMB_DIALECT(SSTOVC(smp
->sm_share
)) < SMB_DIALECT_LANMAN2_0
) {
972 * Name should conform 8.3 format
976 cp
= index(name
, '.');
979 if (cp
== name
|| (cp
- name
) > 8)
981 cp
= index(cp
+ 1, '.');
984 for (cp
= name
, i
= 0; i
< nmlen
; i
++, cp
++)
985 if (index(badchars83
, *cp
) != NULL
)
988 for (cp
= name
, i
= 0; i
< nmlen
; i
++, cp
++)
989 if (index(badchars
, *cp
) != NULL
)
995 * Things go even weird without fixed inode numbers...
997 * smbfs_lookup(struct vnode *a_dvp, struct vnode **a_vpp,
998 * struct componentname *a_cnp)
1001 smbfs_lookup(struct vop_old_lookup_args
*ap
)
1003 struct componentname
*cnp
= ap
->a_cnp
;
1004 struct thread
*td
= cnp
->cn_td
;
1005 struct vnode
*dvp
= ap
->a_dvp
;
1006 struct vnode
**vpp
= ap
->a_vpp
;
1008 struct smbmount
*smp
;
1009 struct mount
*mp
= dvp
->v_mount
;
1010 struct smbnode
*dnp
;
1011 struct smbfattr fattr
, *fap
;
1012 struct smb_cred scred
;
1013 char *name
= cnp
->cn_nameptr
;
1014 int flags
= cnp
->cn_flags
;
1015 int nameiop
= cnp
->cn_nameiop
;
1016 int nmlen
= cnp
->cn_namelen
;
1017 int lockparent
, wantparent
, error
, isdot
;
1020 cnp
->cn_flags
&= ~CNP_PDIRUNLOCK
;
1022 if (dvp
->v_type
!= VDIR
)
1024 if ((flags
& CNP_ISDOTDOT
) && (dvp
->v_flag
& VROOT
)) {
1025 SMBFSERR("invalid '..'\n");
1028 #ifdef SMB_VNODE_DEBUG
1035 SMBVDEBUG("%d '%s' in '%s' id=d\n", nameiop
, name
,
1036 VTOSMB(dvp
)->n_name
);
1040 if ((mp
->mnt_flag
& MNT_RDONLY
) && nameiop
!= NAMEI_LOOKUP
)
1042 if ((error
= VOP_EACCESS(dvp
, VEXEC
, cnp
->cn_cred
)) != 0)
1044 lockparent
= flags
& CNP_LOCKPARENT
;
1045 wantparent
= flags
& (CNP_LOCKPARENT
| CNP_WANTPARENT
);
1046 smp
= VFSTOSMBFS(mp
);
1048 isdot
= (nmlen
== 1 && name
[0] == '.');
1050 error
= smbfs_pathcheck(smp
, cnp
->cn_nameptr
, cnp
->cn_namelen
, nameiop
);
1056 smb_makescred(&scred
, td
, cnp
->cn_cred
);
1058 if (flags
& CNP_ISDOTDOT
) {
1059 error
= smbfs_smb_lookup(VTOSMB(dnp
->n_parent
), NULL
, 0, fap
,
1061 SMBVDEBUG("result of dotdot lookup: %d\n", error
);
1064 error
= smbfs_smb_lookup(dnp
, name
, nmlen
, fap
, &scred
);
1065 /* if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.')*/
1066 SMBVDEBUG("result of smbfs_smb_lookup: %d\n", error
);
1068 if (error
&& error
!= ENOENT
)
1070 if (error
) { /* entry not found */
1072 * Handle RENAME or CREATE case...
1074 if ((nameiop
== NAMEI_CREATE
|| nameiop
== NAMEI_RENAME
) && wantparent
) {
1075 error
= VOP_EACCESS(dvp
, VWRITE
, cnp
->cn_cred
);
1080 cnp
->cn_flags
|= CNP_PDIRUNLOCK
;
1082 return (EJUSTRETURN
);
1086 SMBVDEBUG("Found entry %s with id=%d\n", fap->entryName, fap->dirEntNum);
1089 * handle DELETE case ...
1091 if (nameiop
== NAMEI_DELETE
) { /* delete last component */
1092 error
= VOP_EACCESS(dvp
, VWRITE
, cnp
->cn_cred
);
1100 error
= smbfs_nget(mp
, dvp
, name
, nmlen
, fap
, &vp
);
1106 cnp
->cn_flags
|= CNP_PDIRUNLOCK
;
1110 if (nameiop
== NAMEI_RENAME
&& wantparent
) {
1111 error
= VOP_EACCESS(dvp
, VWRITE
, cnp
->cn_cred
);
1116 error
= smbfs_nget(mp
, dvp
, name
, nmlen
, fap
, &vp
);
1122 cnp
->cn_flags
|= CNP_PDIRUNLOCK
;
1126 if (flags
& CNP_ISDOTDOT
) {
1128 error
= smbfs_nget(mp
, dvp
, name
, nmlen
, NULL
, &vp
);
1130 vn_lock(dvp
, LK_EXCLUSIVE
| LK_RETRY
);
1134 error
= vn_lock(dvp
, LK_EXCLUSIVE
);
1136 cnp
->cn_flags
|= CNP_PDIRUNLOCK
;
1146 error
= smbfs_nget(mp
, dvp
, name
, nmlen
, fap
, &vp
);
1150 SMBVDEBUG("lookup: getnewvp!\n");
1153 cnp
->cn_flags
|= CNP_PDIRUNLOCK
;