Commit | Line | Data |
---|---|---|
984263bc | 1 | /* $FreeBSD: src/sys/msdosfs/msdosfs_vnops.c,v 1.95.2.4 2003/06/13 15:05:47 trhodes Exp $ */ |
84009d92 | 2 | /* $DragonFly: src/sys/vfs/msdosfs/msdosfs_vnops.c,v 1.54 2007/11/20 21:03:50 dillon Exp $ */ |
984263bc MD |
3 | /* $NetBSD: msdosfs_vnops.c,v 1.68 1998/02/10 14:10:04 mrg Exp $ */ |
4 | ||
5 | /*- | |
6 | * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank. | |
7 | * Copyright (C) 1994, 1995, 1997 TooLs GmbH. | |
8 | * All rights reserved. | |
9 | * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below). | |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or without | |
12 | * modification, are permitted provided that the following conditions | |
13 | * are met: | |
14 | * 1. Redistributions of source code must retain the above copyright | |
15 | * notice, this list of conditions and the following disclaimer. | |
16 | * 2. Redistributions in binary form must reproduce the above copyright | |
17 | * notice, this list of conditions and the following disclaimer in the | |
18 | * documentation and/or other materials provided with the distribution. | |
19 | * 3. All advertising materials mentioning features or use of this software | |
20 | * must display the following acknowledgement: | |
21 | * This product includes software developed by TooLs GmbH. | |
22 | * 4. The name of TooLs GmbH may not be used to endorse or promote products | |
23 | * derived from this software without specific prior written permission. | |
24 | * | |
25 | * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR | |
26 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |
27 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |
28 | * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
29 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
30 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | |
31 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
32 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
33 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |
34 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
35 | */ | |
36 | /* | |
37 | * Written by Paul Popelka (paulp@uts.amdahl.com) | |
38 | * | |
39 | * You can do anything you want with this software, just don't say you wrote | |
40 | * it, and don't remove this notice. | |
41 | * | |
42 | * This software is provided "as is". | |
43 | * | |
44 | * The author supplies this software to be publicly redistributed on the | |
45 | * understanding that the author is not responsible for the correct | |
46 | * functioning of this software in any circumstances and is not liable for | |
47 | * any damages caused by this software. | |
48 | * | |
49 | * October 1992 | |
50 | */ | |
51 | ||
52 | #include <sys/param.h> | |
53 | #include <sys/systm.h> | |
984263bc MD |
54 | #include <sys/resourcevar.h> /* defines plimit structure in proc struct */ |
55 | #include <sys/kernel.h> | |
56 | #include <sys/stat.h> | |
57 | #include <sys/buf.h> | |
58 | #include <sys/proc.h> | |
895c1f85 | 59 | #include <sys/priv.h> |
dadab5e9 | 60 | #include <sys/namei.h> |
984263bc MD |
61 | #include <sys/mount.h> |
62 | #include <sys/unistd.h> | |
63 | #include <sys/vnode.h> | |
64 | #include <sys/malloc.h> | |
65 | #include <sys/dirent.h> | |
66 | #include <sys/signalvar.h> | |
67 | ||
68 | #include <vm/vm.h> | |
69 | #include <vm/vm_extern.h> | |
70 | #include <vm/vm_zone.h> | |
71 | #include <vm/vnode_pager.h> | |
72 | ||
3020e3be MD |
73 | #include <sys/buf2.h> |
74 | ||
1f2de5d4 MD |
75 | #include "bpb.h" |
76 | #include "direntry.h" | |
77 | #include "denode.h" | |
78 | #include "msdosfsmount.h" | |
79 | #include "fat.h" | |
984263bc MD |
80 | |
81 | #define DOS_FILESIZE_MAX 0xffffffff | |
82 | ||
83 | /* | |
84 | * Prototypes for MSDOSFS vnode operations | |
85 | */ | |
e62afb5f MD |
86 | static int msdosfs_create (struct vop_old_create_args *); |
87 | static int msdosfs_mknod (struct vop_old_mknod_args *); | |
7540ab49 | 88 | static int msdosfs_open (struct vop_open_args *); |
a6ee311a RG |
89 | static int msdosfs_close (struct vop_close_args *); |
90 | static int msdosfs_access (struct vop_access_args *); | |
91 | static int msdosfs_getattr (struct vop_getattr_args *); | |
92 | static int msdosfs_setattr (struct vop_setattr_args *); | |
93 | static int msdosfs_read (struct vop_read_args *); | |
94 | static int msdosfs_write (struct vop_write_args *); | |
95 | static int msdosfs_fsync (struct vop_fsync_args *); | |
e62afb5f MD |
96 | static int msdosfs_remove (struct vop_old_remove_args *); |
97 | static int msdosfs_link (struct vop_old_link_args *); | |
98 | static int msdosfs_rename (struct vop_old_rename_args *); | |
99 | static int msdosfs_mkdir (struct vop_old_mkdir_args *); | |
100 | static int msdosfs_rmdir (struct vop_old_rmdir_args *); | |
101 | static int msdosfs_symlink (struct vop_old_symlink_args *); | |
a6ee311a RG |
102 | static int msdosfs_readdir (struct vop_readdir_args *); |
103 | static int msdosfs_bmap (struct vop_bmap_args *); | |
104 | static int msdosfs_strategy (struct vop_strategy_args *); | |
105 | static int msdosfs_print (struct vop_print_args *); | |
106 | static int msdosfs_pathconf (struct vop_pathconf_args *ap); | |
984263bc MD |
107 | |
108 | /* | |
109 | * Some general notes: | |
110 | * | |
111 | * In the ufs filesystem the inodes, superblocks, and indirect blocks are | |
112 | * read/written using the vnode for the filesystem. Blocks that represent | |
113 | * the contents of a file are read/written using the vnode for the file | |
114 | * (including directories when they are read/written as files). This | |
115 | * presents problems for the dos filesystem because data that should be in | |
116 | * an inode (if dos had them) resides in the directory itself. Since we | |
117 | * must update directory entries without the benefit of having the vnode | |
118 | * for the directory we must use the vnode for the filesystem. This means | |
119 | * that when a directory is actually read/written (via read, write, or | |
120 | * readdir, or seek) we must use the vnode for the filesystem instead of | |
121 | * the vnode for the directory as would happen in ufs. This is to insure we | |
122 | * retreive the correct block from the buffer cache since the hash value is | |
123 | * based upon the vnode address and the desired block number. | |
124 | */ | |
125 | ||
126 | /* | |
127 | * Create a regular file. On entry the directory to contain the file being | |
fad57d0e | 128 | * created is locked. We must release before we return. |
4625f023 CP |
129 | * |
130 | * msdosfs_create(struct vnode *a_dvp, struct vnode **a_vpp, | |
131 | * struct componentname *a_cnp, struct vattr *a_vap) | |
984263bc MD |
132 | */ |
133 | static int | |
e62afb5f | 134 | msdosfs_create(struct vop_old_create_args *ap) |
984263bc MD |
135 | { |
136 | struct componentname *cnp = ap->a_cnp; | |
137 | struct denode ndirent; | |
138 | struct denode *dep; | |
139 | struct denode *pdep = VTODE(ap->a_dvp); | |
140 | struct timespec ts; | |
141 | int error; | |
142 | ||
143 | #ifdef MSDOSFS_DEBUG | |
086c1d7e | 144 | kprintf("msdosfs_create(cnp %p, vap %p\n", cnp, ap->a_vap); |
984263bc MD |
145 | #endif |
146 | ||
147 | /* | |
148 | * If this is the root directory and there is no space left we | |
149 | * can't do anything. This is because the root directory can not | |
150 | * change size. | |
151 | */ | |
152 | if (pdep->de_StartCluster == MSDOSFSROOT | |
153 | && pdep->de_fndoffset >= pdep->de_FileSize) { | |
154 | error = ENOSPC; | |
155 | goto bad; | |
156 | } | |
157 | ||
158 | /* | |
159 | * Create a directory entry for the file, then call createde() to | |
160 | * have it installed. NOTE: DOS files are always executable. We | |
161 | * use the absence of the owner write bit to make the file | |
162 | * readonly. | |
163 | */ | |
984263bc MD |
164 | bzero(&ndirent, sizeof(ndirent)); |
165 | error = uniqdosname(pdep, cnp, ndirent.de_Name); | |
166 | if (error) | |
167 | goto bad; | |
168 | ||
169 | ndirent.de_Attributes = (ap->a_vap->va_mode & VWRITE) ? | |
170 | ATTR_ARCHIVE : ATTR_ARCHIVE | ATTR_READONLY; | |
171 | ndirent.de_LowerCase = 0; | |
172 | ndirent.de_StartCluster = 0; | |
173 | ndirent.de_FileSize = 0; | |
174 | ndirent.de_dev = pdep->de_dev; | |
175 | ndirent.de_devvp = pdep->de_devvp; | |
176 | ndirent.de_pmp = pdep->de_pmp; | |
177 | ndirent.de_flag = DE_ACCESS | DE_CREATE | DE_UPDATE; | |
178 | getnanotime(&ts); | |
179 | DETIMES(&ndirent, &ts, &ts, &ts); | |
180 | error = createde(&ndirent, pdep, &dep, cnp); | |
181 | if (error) | |
182 | goto bad; | |
183 | *ap->a_vpp = DETOV(dep); | |
184 | return (0); | |
185 | ||
186 | bad: | |
187 | return (error); | |
188 | } | |
189 | ||
4625f023 CP |
190 | /* |
191 | * msdosfs_mknod(struct vnode *a_dvp, struct vnode **a_vpp, | |
192 | * struct componentname *a_cnp, struct vattr *a_vap) | |
193 | */ | |
984263bc | 194 | static int |
e62afb5f | 195 | msdosfs_mknod(struct vop_old_mknod_args *ap) |
984263bc | 196 | { |
984263bc MD |
197 | switch (ap->a_vap->va_type) { |
198 | case VDIR: | |
e62afb5f | 199 | return (msdosfs_mkdir((struct vop_old_mkdir_args *)ap)); |
984263bc MD |
200 | break; |
201 | ||
202 | case VREG: | |
e62afb5f | 203 | return (msdosfs_create((struct vop_old_create_args *)ap)); |
984263bc MD |
204 | break; |
205 | ||
206 | default: | |
207 | return (EINVAL); | |
208 | } | |
209 | /* NOTREACHED */ | |
210 | } | |
211 | ||
7540ab49 | 212 | /* |
b478fdce SW |
213 | * msdosfs_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred, |
214 | * struct file *a_fp) | |
7540ab49 MD |
215 | */ |
216 | static int | |
217 | msdosfs_open(struct vop_open_args *ap) | |
218 | { | |
8ddc6004 | 219 | return(vop_stdopen(ap)); |
7540ab49 MD |
220 | } |
221 | ||
4625f023 | 222 | /* |
b478fdce | 223 | * msdosfs_close(struct vnode *a_vp, int a_fflag) |
4625f023 | 224 | */ |
984263bc | 225 | static int |
4625f023 | 226 | msdosfs_close(struct vop_close_args *ap) |
984263bc MD |
227 | { |
228 | struct vnode *vp = ap->a_vp; | |
229 | struct denode *dep = VTODE(vp); | |
230 | struct timespec ts; | |
231 | ||
3c37c940 | 232 | if (vp->v_sysref.refcnt > 1) { |
984263bc | 233 | getnanotime(&ts); |
3c37c940 | 234 | DETIMES(dep, &ts, &ts, &ts); |
984263bc | 235 | } |
8ddc6004 | 236 | return (vop_stdclose(ap)); |
984263bc MD |
237 | } |
238 | ||
4625f023 | 239 | /* |
b478fdce | 240 | * msdosfs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred) |
4625f023 | 241 | */ |
984263bc | 242 | static int |
4625f023 | 243 | msdosfs_access(struct vop_access_args *ap) |
984263bc MD |
244 | { |
245 | struct vnode *vp = ap->a_vp; | |
246 | struct denode *dep = VTODE(ap->a_vp); | |
247 | struct msdosfsmount *pmp = dep->de_pmp; | |
248 | struct ucred *cred = ap->a_cred; | |
249 | mode_t mask, file_mode, mode = ap->a_mode; | |
0e99e805 | 250 | gid_t *gp; |
984263bc MD |
251 | int i; |
252 | ||
253 | file_mode = (S_IXUSR|S_IXGRP|S_IXOTH) | (S_IRUSR|S_IRGRP|S_IROTH) | | |
254 | ((dep->de_Attributes & ATTR_READONLY) ? 0 : (S_IWUSR|S_IWGRP|S_IWOTH)); | |
255 | file_mode &= pmp->pm_mask; | |
256 | ||
257 | /* | |
258 | * Disallow write attempts on read-only file systems; | |
259 | * unless the file is a socket, fifo, or a block or | |
260 | * character device resident on the file system. | |
261 | */ | |
262 | if (mode & VWRITE) { | |
263 | switch (vp->v_type) { | |
264 | case VDIR: | |
265 | case VLNK: | |
266 | case VREG: | |
267 | if (vp->v_mount->mnt_flag & MNT_RDONLY) | |
268 | return (EROFS); | |
269 | break; | |
270 | default: | |
271 | break; | |
272 | } | |
273 | } | |
274 | ||
275 | /* User id 0 always gets access. */ | |
276 | if (cred->cr_uid == 0) | |
277 | return 0; | |
278 | ||
279 | mask = 0; | |
280 | ||
281 | /* Otherwise, check the owner. */ | |
282 | if (cred->cr_uid == pmp->pm_uid) { | |
283 | if (mode & VEXEC) | |
284 | mask |= S_IXUSR; | |
285 | if (mode & VREAD) | |
286 | mask |= S_IRUSR; | |
287 | if (mode & VWRITE) | |
288 | mask |= S_IWUSR; | |
289 | return (file_mode & mask) == mask ? 0 : EACCES; | |
290 | } | |
291 | ||
292 | /* Otherwise, check the groups. */ | |
293 | for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++) | |
294 | if (pmp->pm_gid == *gp) { | |
295 | if (mode & VEXEC) | |
296 | mask |= S_IXGRP; | |
297 | if (mode & VREAD) | |
298 | mask |= S_IRGRP; | |
299 | if (mode & VWRITE) | |
300 | mask |= S_IWGRP; | |
301 | return (file_mode & mask) == mask ? 0 : EACCES; | |
302 | } | |
303 | ||
304 | /* Otherwise, check everyone else. */ | |
305 | if (mode & VEXEC) | |
306 | mask |= S_IXOTH; | |
307 | if (mode & VREAD) | |
308 | mask |= S_IROTH; | |
309 | if (mode & VWRITE) | |
310 | mask |= S_IWOTH; | |
311 | return (file_mode & mask) == mask ? 0 : EACCES; | |
312 | } | |
313 | ||
4625f023 | 314 | /* |
b478fdce | 315 | * msdosfs_getattr(struct vnode *a_vp, struct vattr *a_vap) |
4625f023 | 316 | */ |
984263bc | 317 | static int |
4625f023 | 318 | msdosfs_getattr(struct vop_getattr_args *ap) |
984263bc MD |
319 | { |
320 | struct denode *dep = VTODE(ap->a_vp); | |
321 | struct msdosfsmount *pmp = dep->de_pmp; | |
322 | struct vattr *vap = ap->a_vap; | |
323 | mode_t mode; | |
324 | struct timespec ts; | |
325 | u_long dirsperblk = pmp->pm_BytesPerSec / sizeof(struct direntry); | |
326 | u_long fileid; | |
327 | ||
328 | getnanotime(&ts); | |
329 | DETIMES(dep, &ts, &ts, &ts); | |
330 | vap->va_fsid = dev2udev(dep->de_dev); | |
331 | /* | |
332 | * The following computation of the fileid must be the same as that | |
333 | * used in msdosfs_readdir() to compute d_fileno. If not, pwd | |
334 | * doesn't work. | |
335 | */ | |
336 | if (dep->de_Attributes & ATTR_DIRECTORY) { | |
4afd80f1 | 337 | fileid = xcntobn(pmp, dep->de_StartCluster) * dirsperblk; |
984263bc MD |
338 | if (dep->de_StartCluster == MSDOSFSROOT) |
339 | fileid = 1; | |
340 | } else { | |
4afd80f1 | 341 | fileid = xcntobn(pmp, dep->de_dirclust) * dirsperblk; |
984263bc MD |
342 | if (dep->de_dirclust == MSDOSFSROOT) |
343 | fileid = roottobn(pmp, 0) * dirsperblk; | |
344 | fileid += dep->de_diroffset / sizeof(struct direntry); | |
345 | } | |
346 | vap->va_fileid = fileid; | |
347 | if ((dep->de_Attributes & ATTR_READONLY) == 0) | |
348 | mode = S_IRWXU|S_IRWXG|S_IRWXO; | |
349 | else | |
350 | mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH; | |
351 | vap->va_mode = mode & pmp->pm_mask; | |
352 | vap->va_uid = pmp->pm_uid; | |
353 | vap->va_gid = pmp->pm_gid; | |
354 | vap->va_nlink = 1; | |
0e9b9130 MD |
355 | vap->va_rmajor = VNOVAL; |
356 | vap->va_rminor = VNOVAL; | |
984263bc MD |
357 | vap->va_size = dep->de_FileSize; |
358 | dos2unixtime(dep->de_MDate, dep->de_MTime, 0, &vap->va_mtime); | |
359 | if (pmp->pm_flags & MSDOSFSMNT_LONGNAME) { | |
360 | dos2unixtime(dep->de_ADate, 0, 0, &vap->va_atime); | |
361 | dos2unixtime(dep->de_CDate, dep->de_CTime, dep->de_CHun, &vap->va_ctime); | |
362 | } else { | |
363 | vap->va_atime = vap->va_mtime; | |
364 | vap->va_ctime = vap->va_mtime; | |
365 | } | |
366 | vap->va_flags = 0; | |
367 | if ((dep->de_Attributes & ATTR_ARCHIVE) == 0) | |
368 | vap->va_flags |= SF_ARCHIVED; | |
369 | vap->va_gen = 0; | |
370 | vap->va_blocksize = pmp->pm_bpcluster; | |
371 | vap->va_bytes = | |
372 | (dep->de_FileSize + pmp->pm_crbomask) & ~pmp->pm_crbomask; | |
373 | vap->va_type = ap->a_vp->v_type; | |
374 | vap->va_filerev = dep->de_modrev; | |
375 | return (0); | |
376 | } | |
377 | ||
4625f023 CP |
378 | /* |
379 | * msdosfs_setattr(struct vnode *a_vp, struct vattr *a_vap, | |
b478fdce | 380 | * struct ucred *a_cred) |
4625f023 | 381 | */ |
984263bc | 382 | static int |
4625f023 | 383 | msdosfs_setattr(struct vop_setattr_args *ap) |
984263bc MD |
384 | { |
385 | struct vnode *vp = ap->a_vp; | |
386 | struct denode *dep = VTODE(ap->a_vp); | |
387 | struct msdosfsmount *pmp = dep->de_pmp; | |
388 | struct vattr *vap = ap->a_vap; | |
389 | struct ucred *cred = ap->a_cred; | |
390 | int error = 0; | |
391 | ||
392 | #ifdef MSDOSFS_DEBUG | |
0e63c0c7 SW |
393 | kprintf("msdosfs_setattr(): vp %p, vap %p, cred %p\n", |
394 | ap->a_vp, vap, cred); | |
984263bc MD |
395 | #endif |
396 | ||
397 | /* | |
398 | * Check for unsettable attributes. | |
399 | */ | |
400 | if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || | |
401 | (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || | |
0e9b9130 | 402 | (vap->va_blocksize != VNOVAL) || (vap->va_rmajor != VNOVAL) || |
984263bc MD |
403 | (vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { |
404 | #ifdef MSDOSFS_DEBUG | |
086c1d7e | 405 | kprintf("msdosfs_setattr(): returning EINVAL\n"); |
50626622 | 406 | kprintf(" va_type %d, va_nlink %llx, va_fsid %x, va_fileid %llx\n", |
984263bc | 407 | vap->va_type, vap->va_nlink, vap->va_fsid, vap->va_fileid); |
50626622 | 408 | kprintf(" va_blocksize %lx, va_rmajor %x, va_bytes %qx, va_gen %llx\n", |
0e9b9130 | 409 | vap->va_blocksize, vap->va_rmajor, vap->va_bytes, vap->va_gen); |
086c1d7e | 410 | kprintf(" va_uid %x, va_gid %x\n", |
984263bc MD |
411 | vap->va_uid, vap->va_gid); |
412 | #endif | |
413 | return (EINVAL); | |
414 | } | |
415 | if (vap->va_flags != VNOVAL) { | |
416 | if (vp->v_mount->mnt_flag & MNT_RDONLY) | |
417 | return (EROFS); | |
418 | if (cred->cr_uid != pmp->pm_uid && | |
db813a0c | 419 | (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0))) |
984263bc MD |
420 | return (error); |
421 | /* | |
422 | * We are very inconsistent about handling unsupported | |
423 | * attributes. We ignored the access time and the | |
424 | * read and execute bits. We were strict for the other | |
425 | * attributes. | |
426 | * | |
427 | * Here we are strict, stricter than ufs in not allowing | |
428 | * users to attempt to set SF_SETTABLE bits or anyone to | |
429 | * set unsupported bits. However, we ignore attempts to | |
430 | * set ATTR_ARCHIVE for directories `cp -pr' from a more | |
431 | * sensible file system attempts it a lot. | |
432 | */ | |
433 | if (cred->cr_uid != 0) { | |
434 | if (vap->va_flags & SF_SETTABLE) | |
435 | return EPERM; | |
436 | } | |
437 | if (vap->va_flags & ~SF_ARCHIVED) | |
438 | return EOPNOTSUPP; | |
439 | if (vap->va_flags & SF_ARCHIVED) | |
440 | dep->de_Attributes &= ~ATTR_ARCHIVE; | |
441 | else if (!(dep->de_Attributes & ATTR_DIRECTORY)) | |
442 | dep->de_Attributes |= ATTR_ARCHIVE; | |
443 | dep->de_flag |= DE_MODIFIED; | |
444 | } | |
445 | ||
446 | if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { | |
447 | uid_t uid; | |
448 | gid_t gid; | |
449 | ||
450 | if (vp->v_mount->mnt_flag & MNT_RDONLY) | |
451 | return (EROFS); | |
452 | uid = vap->va_uid; | |
453 | if (uid == (uid_t)VNOVAL) | |
454 | uid = pmp->pm_uid; | |
455 | gid = vap->va_gid; | |
456 | if (gid == (gid_t)VNOVAL) | |
457 | gid = pmp->pm_gid; | |
458 | if ((cred->cr_uid != pmp->pm_uid || uid != pmp->pm_uid || | |
459 | (gid != pmp->pm_gid && !groupmember(gid, cred))) && | |
db813a0c | 460 | (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0))) |
984263bc MD |
461 | return error; |
462 | if (uid != pmp->pm_uid || gid != pmp->pm_gid) | |
463 | return EINVAL; | |
464 | } | |
465 | ||
466 | if (vap->va_size != VNOVAL) { | |
467 | /* | |
468 | * Disallow write attempts on read-only file systems; | |
469 | * unless the file is a socket, fifo, or a block or | |
470 | * character device resident on the file system. | |
471 | */ | |
472 | switch (vp->v_type) { | |
473 | case VDIR: | |
474 | return (EISDIR); | |
475 | /* NOT REACHED */ | |
476 | case VLNK: | |
477 | case VREG: | |
478 | if (vp->v_mount->mnt_flag & MNT_RDONLY) | |
479 | return (EROFS); | |
480 | break; | |
481 | default: | |
482 | break; | |
483 | } | |
87de5057 | 484 | error = detrunc(dep, vap->va_size, 0); |
984263bc MD |
485 | if (error) |
486 | return error; | |
487 | } | |
488 | if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) { | |
489 | if (vp->v_mount->mnt_flag & MNT_RDONLY) | |
490 | return (EROFS); | |
491 | if (cred->cr_uid != pmp->pm_uid && | |
db813a0c | 492 | (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0)) && |
984263bc | 493 | ((vap->va_vaflags & VA_UTIMES_NULL) == 0 || |
87de5057 | 494 | (error = VOP_ACCESS(ap->a_vp, VWRITE, cred)))) |
984263bc MD |
495 | return (error); |
496 | if (vp->v_type != VDIR) { | |
497 | if ((pmp->pm_flags & MSDOSFSMNT_NOWIN95) == 0 && | |
498 | vap->va_atime.tv_sec != VNOVAL) { | |
499 | dep->de_flag &= ~DE_ACCESS; | |
500 | unix2dostime(&vap->va_atime, &dep->de_ADate, | |
501 | NULL, NULL); | |
502 | } | |
503 | if (vap->va_mtime.tv_sec != VNOVAL) { | |
504 | dep->de_flag &= ~DE_UPDATE; | |
505 | unix2dostime(&vap->va_mtime, &dep->de_MDate, | |
506 | &dep->de_MTime, NULL); | |
507 | } | |
508 | dep->de_Attributes |= ATTR_ARCHIVE; | |
509 | dep->de_flag |= DE_MODIFIED; | |
510 | } | |
511 | } | |
512 | /* | |
513 | * DOS files only have the ability to have their writability | |
514 | * attribute set, so we use the owner write bit to set the readonly | |
515 | * attribute. | |
516 | */ | |
517 | if (vap->va_mode != (mode_t)VNOVAL) { | |
518 | if (vp->v_mount->mnt_flag & MNT_RDONLY) | |
519 | return (EROFS); | |
520 | if (cred->cr_uid != pmp->pm_uid && | |
db813a0c | 521 | (error = priv_check_cred(cred, PRIV_VFS_SETATTR, 0))) |
984263bc MD |
522 | return (error); |
523 | if (vp->v_type != VDIR) { | |
524 | /* We ignore the read and execute bits. */ | |
525 | if (vap->va_mode & VWRITE) | |
526 | dep->de_Attributes &= ~ATTR_READONLY; | |
527 | else | |
528 | dep->de_Attributes |= ATTR_READONLY; | |
529 | dep->de_Attributes |= ATTR_ARCHIVE; | |
530 | dep->de_flag |= DE_MODIFIED; | |
531 | } | |
532 | } | |
533 | return (deupdat(dep, 1)); | |
534 | } | |
535 | ||
4625f023 CP |
536 | /* |
537 | * msdosfs_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, | |
538 | * struct ucred *a_cred) | |
539 | */ | |
984263bc | 540 | static int |
4625f023 | 541 | msdosfs_read(struct vop_read_args *ap) |
984263bc MD |
542 | { |
543 | int error = 0; | |
544 | int blsize; | |
545 | int isadir; | |
e54488bb | 546 | size_t orig_resid; |
984263bc MD |
547 | u_int n; |
548 | u_long diff; | |
549 | u_long on; | |
550 | daddr_t lbn; | |
551 | daddr_t rablock; | |
54078292 MD |
552 | off_t raoffset; |
553 | off_t loffset; | |
984263bc MD |
554 | int rasize; |
555 | int seqcount; | |
556 | struct buf *bp; | |
557 | struct vnode *vp = ap->a_vp; | |
558 | struct denode *dep = VTODE(vp); | |
559 | struct msdosfsmount *pmp = dep->de_pmp; | |
560 | struct uio *uio = ap->a_uio; | |
561 | ||
562 | if (uio->uio_offset < 0) | |
563 | return (EINVAL); | |
564 | ||
565 | if ((uoff_t)uio->uio_offset > DOS_FILESIZE_MAX) | |
566 | return (0); | |
567 | /* | |
568 | * If they didn't ask for any data, then we are done. | |
569 | */ | |
570 | orig_resid = uio->uio_resid; | |
e54488bb | 571 | if (orig_resid == 0) |
984263bc MD |
572 | return (0); |
573 | ||
574 | seqcount = ap->a_ioflag >> IO_SEQSHIFT; | |
575 | ||
576 | isadir = dep->de_Attributes & ATTR_DIRECTORY; | |
577 | do { | |
578 | if (uio->uio_offset >= dep->de_FileSize) | |
579 | break; | |
4afd80f1 MD |
580 | |
581 | /* | |
582 | * note: lbn is a cluster number, not a device block number. | |
583 | */ | |
584 | lbn = de_off2cn(pmp, uio->uio_offset); | |
585 | loffset = de_cn2doff(pmp, lbn); | |
586 | ||
984263bc MD |
587 | /* |
588 | * If we are operating on a directory file then be sure to | |
589 | * do i/o with the vnode for the filesystem instead of the | |
590 | * vnode for the directory. | |
591 | */ | |
592 | if (isadir) { | |
4afd80f1 MD |
593 | /* |
594 | * convert cluster # to block #. lbn is a | |
595 | * device block number after this. | |
596 | */ | |
597 | error = pcbmap(dep, lbn, &lbn, NULL, &blsize); | |
598 | loffset = de_bntodoff(pmp, lbn); | |
984263bc MD |
599 | if (error == E2BIG) { |
600 | error = EINVAL; | |
601 | break; | |
602 | } else if (error) | |
603 | break; | |
54078292 | 604 | error = bread(pmp->pm_devvp, loffset, blsize, &bp); |
984263bc MD |
605 | } else { |
606 | blsize = pmp->pm_bpcluster; | |
607 | rablock = lbn + 1; | |
4afd80f1 | 608 | raoffset = de_cn2doff(pmp, rablock); |
984263bc | 609 | if (seqcount > 1 && |
54078292 | 610 | raoffset < dep->de_FileSize) { |
984263bc | 611 | rasize = pmp->pm_bpcluster; |
54078292 MD |
612 | error = breadn(vp, loffset, blsize, |
613 | &raoffset, &rasize, 1, &bp); | |
984263bc | 614 | } else { |
54078292 | 615 | error = bread(vp, loffset, blsize, &bp); |
984263bc MD |
616 | } |
617 | } | |
618 | if (error) { | |
619 | brelse(bp); | |
620 | break; | |
621 | } | |
622 | on = uio->uio_offset & pmp->pm_crbomask; | |
623 | diff = pmp->pm_bpcluster - on; | |
e54488bb | 624 | n = szmin(uio->uio_resid, diff); |
984263bc MD |
625 | diff = dep->de_FileSize - uio->uio_offset; |
626 | if (diff < n) | |
627 | n = diff; | |
628 | diff = blsize - bp->b_resid; | |
629 | if (diff < n) | |
630 | n = diff; | |
e54488bb | 631 | error = uiomove(bp->b_data + on, (size_t)n, uio); |
984263bc MD |
632 | brelse(bp); |
633 | } while (error == 0 && uio->uio_resid > 0 && n != 0); | |
634 | if (!isadir && (error == 0 || uio->uio_resid != orig_resid) && | |
635 | (vp->v_mount->mnt_flag & MNT_NOATIME) == 0) | |
636 | dep->de_flag |= DE_ACCESS; | |
637 | return (error); | |
638 | } | |
639 | ||
640 | /* | |
641 | * Write data to a file or directory. | |
4625f023 CP |
642 | * |
643 | * msdosfs_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag, | |
644 | * struct ucred *a_cred) | |
984263bc MD |
645 | */ |
646 | static int | |
4625f023 | 647 | msdosfs_write(struct vop_write_args *ap) |
984263bc MD |
648 | { |
649 | int n; | |
650 | int croffset; | |
e54488bb | 651 | size_t resid; |
984263bc MD |
652 | u_long osize; |
653 | int error = 0; | |
654 | u_long count; | |
4afd80f1 | 655 | daddr_t cn, lastcn; |
984263bc MD |
656 | struct buf *bp; |
657 | int ioflag = ap->a_ioflag; | |
658 | struct uio *uio = ap->a_uio; | |
dadab5e9 | 659 | struct thread *td = uio->uio_td; |
984263bc MD |
660 | struct vnode *vp = ap->a_vp; |
661 | struct vnode *thisvp; | |
662 | struct denode *dep = VTODE(vp); | |
663 | struct msdosfsmount *pmp = dep->de_pmp; | |
049d6e6d | 664 | struct proc *p = (td ? td->td_proc : NULL); |
7278a846 | 665 | struct lwp *lp = (td ? td->td_lwp : NULL); |
984263bc MD |
666 | |
667 | #ifdef MSDOSFS_DEBUG | |
086c1d7e | 668 | kprintf("msdosfs_write(vp %p, uio %p, ioflag %x, cred %p\n", |
0e63c0c7 | 669 | vp, uio, ioflag, ap->a_cred); |
086c1d7e | 670 | kprintf("msdosfs_write(): diroff %lu, dirclust %lu, startcluster %lu\n", |
984263bc MD |
671 | dep->de_diroffset, dep->de_dirclust, dep->de_StartCluster); |
672 | #endif | |
673 | ||
674 | switch (vp->v_type) { | |
675 | case VREG: | |
676 | if (ioflag & IO_APPEND) | |
677 | uio->uio_offset = dep->de_FileSize; | |
678 | thisvp = vp; | |
679 | break; | |
680 | case VDIR: | |
681 | return EISDIR; | |
682 | default: | |
683 | panic("msdosfs_write(): bad file type"); | |
684 | } | |
685 | ||
686 | if (uio->uio_offset < 0) | |
687 | return (EFBIG); | |
688 | ||
689 | if (uio->uio_resid == 0) | |
690 | return (0); | |
691 | ||
692 | /* | |
693 | * If they've exceeded their filesize limit, tell them about it. | |
694 | */ | |
695 | if (p && | |
696 | ((uoff_t)uio->uio_offset + uio->uio_resid > | |
697 | p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) { | |
7278a846 | 698 | lwpsignal(p, lp, SIGXFSZ); |
984263bc MD |
699 | return (EFBIG); |
700 | } | |
701 | ||
e54488bb MD |
702 | if ((uoff_t)uio->uio_offset > DOS_FILESIZE_MAX) |
703 | return (EFBIG); | |
984263bc MD |
704 | if ((uoff_t)uio->uio_offset + uio->uio_resid > DOS_FILESIZE_MAX) |
705 | return (EFBIG); | |
706 | ||
707 | /* | |
708 | * If the offset we are starting the write at is beyond the end of | |
709 | * the file, then they've done a seek. Unix filesystems allow | |
710 | * files with holes in them, DOS doesn't so we must fill the hole | |
711 | * with zeroed blocks. | |
712 | */ | |
713 | if (uio->uio_offset > dep->de_FileSize) { | |
3b568787 | 714 | error = deextend(dep, uio->uio_offset); |
984263bc MD |
715 | if (error) |
716 | return (error); | |
717 | } | |
718 | ||
719 | /* | |
720 | * Remember some values in case the write fails. | |
721 | */ | |
722 | resid = uio->uio_resid; | |
723 | osize = dep->de_FileSize; | |
724 | ||
725 | /* | |
726 | * If we write beyond the end of the file, extend it to its ultimate | |
727 | * size ahead of the time to hopefully get a contiguous area. | |
728 | */ | |
729 | if (uio->uio_offset + resid > osize) { | |
730 | count = de_clcount(pmp, uio->uio_offset + resid) - | |
731 | de_clcount(pmp, osize); | |
732 | error = extendfile(dep, count, NULL, NULL, 0); | |
733 | if (error && (error != ENOSPC || (ioflag & IO_UNIT))) | |
734 | goto errexit; | |
735 | lastcn = dep->de_fc[FC_LASTFC].fc_frcn; | |
736 | } else | |
737 | lastcn = de_clcount(pmp, osize) - 1; | |
738 | ||
739 | do { | |
4afd80f1 | 740 | if (de_off2cn(pmp, uio->uio_offset) > lastcn) { |
984263bc MD |
741 | error = ENOSPC; |
742 | break; | |
743 | } | |
744 | ||
745 | croffset = uio->uio_offset & pmp->pm_crbomask; | |
e54488bb | 746 | n = (int)szmin(uio->uio_resid, pmp->pm_bpcluster - croffset); |
984263bc MD |
747 | if (uio->uio_offset + n > dep->de_FileSize) { |
748 | dep->de_FileSize = uio->uio_offset + n; | |
749 | /* The object size needs to be set before buffer is allocated */ | |
750 | vnode_pager_setsize(vp, dep->de_FileSize); | |
751 | } | |
752 | ||
8aa7625b MD |
753 | /* |
754 | * If either the whole cluster gets written, or we write | |
755 | * the cluster from its start beyond EOF, then no need to | |
756 | * read data from disk. | |
757 | * | |
758 | * If UIO_NOCOPY is set we have to do a read-before-write | |
759 | * to fill in any missing pieces of the buffer since no | |
760 | * actual overwrite will occur. | |
761 | */ | |
4afd80f1 | 762 | cn = de_off2cn(pmp, uio->uio_offset); |
984263bc | 763 | if ((uio->uio_offset & pmp->pm_crbomask) == 0 |
8aa7625b | 764 | && uio->uio_segflg != UIO_NOCOPY |
4afd80f1 MD |
765 | && (de_off2cn(pmp, uio->uio_offset + uio->uio_resid) |
766 | > de_off2cn(pmp, uio->uio_offset) | |
984263bc | 767 | || uio->uio_offset + uio->uio_resid >= dep->de_FileSize)) { |
4afd80f1 | 768 | bp = getblk(thisvp, de_cn2doff(pmp, cn), |
54078292 | 769 | pmp->pm_bpcluster, 0, 0); |
984263bc MD |
770 | clrbuf(bp); |
771 | /* | |
772 | * Do the bmap now, since pcbmap needs buffers | |
773 | * for the fat table. (see msdosfs_strategy) | |
774 | */ | |
54078292 | 775 | if (bp->b_bio2.bio_offset == NOOFFSET) { |
4afd80f1 | 776 | daddr_t lblkno = de_off2cn(pmp, bp->b_loffset); |
54078292 MD |
777 | daddr_t dblkno; |
778 | ||
4afd80f1 MD |
779 | error = pcbmap(dep, lblkno, |
780 | &dblkno, NULL, NULL); | |
54078292 MD |
781 | if (error || dblkno == (daddr_t)-1) { |
782 | bp->b_bio2.bio_offset = NOOFFSET; | |
783 | } else { | |
4afd80f1 | 784 | bp->b_bio2.bio_offset = de_bntodoff(pmp, dblkno); |
54078292 | 785 | } |
984263bc | 786 | } |
54078292 | 787 | if (bp->b_bio2.bio_offset == NOOFFSET) { |
984263bc MD |
788 | brelse(bp); |
789 | if (!error) | |
790 | error = EIO; /* XXX */ | |
791 | break; | |
792 | } | |
793 | } else { | |
794 | /* | |
4afd80f1 MD |
795 | * The block we need to write into exists, so read |
796 | * it in. | |
984263bc | 797 | */ |
4afd80f1 MD |
798 | error = bread(thisvp, de_cn2doff(pmp, cn), |
799 | pmp->pm_bpcluster, &bp); | |
984263bc MD |
800 | if (error) { |
801 | brelse(bp); | |
802 | break; | |
803 | } | |
804 | } | |
805 | ||
806 | /* | |
807 | * Should these vnode_pager_* functions be done on dir | |
808 | * files? | |
809 | */ | |
810 | ||
811 | /* | |
812 | * Copy the data from user space into the buf header. | |
813 | */ | |
e54488bb | 814 | error = uiomove(bp->b_data + croffset, (size_t)n, uio); |
984263bc MD |
815 | if (error) { |
816 | brelse(bp); | |
817 | break; | |
818 | } | |
819 | ||
820 | /* | |
821 | * If they want this synchronous then write it and wait for | |
822 | * it. Otherwise, if on a cluster boundary write it | |
823 | * asynchronously so we can move on to the next block | |
824 | * without delay. Otherwise do a delayed write because we | |
825 | * may want to write somemore into the block later. | |
826 | */ | |
827 | if (ioflag & IO_SYNC) | |
b1ce5639 | 828 | bwrite(bp); |
984263bc MD |
829 | else if (n + croffset == pmp->pm_bpcluster) |
830 | bawrite(bp); | |
831 | else | |
832 | bdwrite(bp); | |
833 | dep->de_flag |= DE_UPDATE; | |
834 | } while (error == 0 && uio->uio_resid > 0); | |
835 | ||
836 | /* | |
837 | * If the write failed and they want us to, truncate the file back | |
838 | * to the size it was before the write was attempted. | |
839 | */ | |
840 | errexit: | |
841 | if (error) { | |
842 | if (ioflag & IO_UNIT) { | |
87de5057 | 843 | detrunc(dep, osize, ioflag & IO_SYNC); |
984263bc MD |
844 | uio->uio_offset -= resid - uio->uio_resid; |
845 | uio->uio_resid = resid; | |
846 | } else { | |
87de5057 | 847 | detrunc(dep, dep->de_FileSize, ioflag & IO_SYNC); |
984263bc MD |
848 | if (uio->uio_resid != resid) |
849 | error = 0; | |
850 | } | |
851 | } else if (ioflag & IO_SYNC) | |
852 | error = deupdat(dep, 1); | |
853 | return (error); | |
854 | } | |
855 | ||
856 | /* | |
857 | * Flush the blocks of a file to disk. | |
858 | * | |
859 | * This function is worthless for vnodes that represent directories. Maybe we | |
860 | * could just do a sync if they try an fsync on a directory file. | |
4625f023 | 861 | * |
b478fdce | 862 | * msdosfs_fsync(struct vnode *a_vp, int a_waitfor) |
984263bc MD |
863 | */ |
864 | static int | |
4625f023 | 865 | msdosfs_fsync(struct vop_fsync_args *ap) |
984263bc MD |
866 | { |
867 | struct vnode *vp = ap->a_vp; | |
984263bc MD |
868 | |
869 | /* | |
870 | * Flush all dirty buffers associated with a vnode. | |
871 | */ | |
6bae6177 | 872 | #ifdef DIAGNOSTIC |
984263bc | 873 | loop: |
6bae6177 | 874 | #endif |
4e0ecc94 | 875 | vfsync(vp, ap->a_waitfor, 0, NULL, NULL); |
984263bc | 876 | #ifdef DIAGNOSTIC |
6bae6177 | 877 | if (ap->a_waitfor == MNT_WAIT && !RB_EMPTY(&vp->v_rbdirty_tree)) { |
984263bc MD |
878 | vprint("msdosfs_fsync: dirty", vp); |
879 | goto loop; | |
880 | } | |
881 | #endif | |
984263bc MD |
882 | return (deupdat(VTODE(vp), ap->a_waitfor == MNT_WAIT)); |
883 | } | |
884 | ||
4625f023 CP |
885 | /* |
886 | * msdosfs_remove(struct vnode *a_dvp, struct vnode *a_vp, | |
887 | * struct componentname *a_cnp) | |
888 | */ | |
984263bc | 889 | static int |
e62afb5f | 890 | msdosfs_remove(struct vop_old_remove_args *ap) |
984263bc MD |
891 | { |
892 | struct denode *dep = VTODE(ap->a_vp); | |
893 | struct denode *ddep = VTODE(ap->a_dvp); | |
894 | int error; | |
895 | ||
896 | if (ap->a_vp->v_type == VDIR) | |
897 | error = EPERM; | |
898 | else | |
899 | error = removede(ddep, dep); | |
900 | #ifdef MSDOSFS_DEBUG | |
3c37c940 MD |
901 | kprintf("msdosfs_remove(), dep %p, v_sysrefs %d\n", |
902 | dep, ap->a_vp->v_sysref.refcnt); | |
984263bc MD |
903 | #endif |
904 | return (error); | |
905 | } | |
906 | ||
907 | /* | |
908 | * DOS filesystems don't know what links are. But since we already called | |
909 | * msdosfs_lookup() with create and lockparent, the parent is locked so we | |
910 | * have to free it before we return the error. | |
4625f023 CP |
911 | * |
912 | * msdosfs_link(struct vnode *a_tdvp, struct vnode *a_vp, | |
913 | * struct componentname *a_cnp) | |
984263bc MD |
914 | */ |
915 | static int | |
e62afb5f | 916 | msdosfs_link(struct vop_old_link_args *ap) |
984263bc MD |
917 | { |
918 | return (EOPNOTSUPP); | |
919 | } | |
920 | ||
921 | /* | |
922 | * Renames on files require moving the denode to a new hash queue since the | |
923 | * denode's location is used to compute which hash queue to put the file | |
924 | * in. Unless it is a rename in place. For example "mv a b". | |
925 | * | |
926 | * What follows is the basic algorithm: | |
927 | * | |
928 | * if (file move) { | |
929 | * if (dest file exists) { | |
930 | * remove dest file | |
931 | * } | |
932 | * if (dest and src in same directory) { | |
933 | * rewrite name in existing directory slot | |
934 | * } else { | |
935 | * write new entry in dest directory | |
936 | * update offset and dirclust in denode | |
937 | * move denode to new hash chain | |
938 | * clear old directory entry | |
939 | * } | |
940 | * } else { | |
941 | * directory move | |
942 | * if (dest directory exists) { | |
943 | * if (dest is not empty) { | |
944 | * return ENOTEMPTY | |
945 | * } | |
946 | * remove dest directory | |
947 | * } | |
948 | * if (dest and src in same directory) { | |
949 | * rewrite name in existing entry | |
950 | * } else { | |
951 | * be sure dest is not a child of src directory | |
952 | * write entry in dest directory | |
953 | * update "." and ".." in moved directory | |
954 | * clear old directory entry for moved directory | |
955 | * } | |
956 | * } | |
957 | * | |
958 | * On entry: | |
959 | * source's parent directory is unlocked | |
960 | * source file or directory is unlocked | |
961 | * destination's parent directory is locked | |
962 | * destination file or directory is locked if it exists | |
963 | * | |
964 | * On exit: | |
965 | * all denodes should be released | |
966 | * | |
967 | * Notes: | |
968 | * I'm not sure how the memory containing the pathnames pointed at by the | |
969 | * componentname structures is freed, there may be some memory bleeding | |
970 | * for each rename done. | |
4625f023 CP |
971 | * |
972 | * msdosfs_rename(struct vnode *a_fdvp, struct vnode *a_fvp, | |
973 | * struct componentname *a_fcnp, struct vnode *a_tdvp, | |
974 | * struct vnode *a_tvp, struct componentname *a_tcnp) | |
984263bc MD |
975 | */ |
976 | static int | |
e62afb5f | 977 | msdosfs_rename(struct vop_old_rename_args *ap) |
984263bc MD |
978 | { |
979 | struct vnode *tdvp = ap->a_tdvp; | |
980 | struct vnode *fvp = ap->a_fvp; | |
981 | struct vnode *fdvp = ap->a_fdvp; | |
982 | struct vnode *tvp = ap->a_tvp; | |
983 | struct componentname *tcnp = ap->a_tcnp; | |
984 | struct componentname *fcnp = ap->a_fcnp; | |
984263bc MD |
985 | struct denode *ip, *xp, *dp, *zp; |
986 | u_char toname[11], oldname[11]; | |
987 | u_long from_diroffset, to_diroffset; | |
988 | u_char to_count; | |
989 | int doingdirectory = 0, newparent = 0; | |
990 | int error; | |
991 | u_long cn; | |
992 | daddr_t bn; | |
984263bc MD |
993 | struct msdosfsmount *pmp; |
994 | struct direntry *dotdotp; | |
995 | struct buf *bp; | |
996 | ||
984263bc MD |
997 | pmp = VFSTOMSDOSFS(fdvp->v_mount); |
998 | ||
984263bc MD |
999 | /* |
1000 | * Check for cross-device rename. | |
1001 | */ | |
1002 | if ((fvp->v_mount != tdvp->v_mount) || | |
1003 | (tvp && (fvp->v_mount != tvp->v_mount))) { | |
1004 | error = EXDEV; | |
1005 | abortit: | |
1006 | if (tdvp == tvp) | |
1007 | vrele(tdvp); | |
1008 | else | |
1009 | vput(tdvp); | |
1010 | if (tvp) | |
1011 | vput(tvp); | |
1012 | vrele(fdvp); | |
1013 | vrele(fvp); | |
1014 | return (error); | |
1015 | } | |
1016 | ||
1017 | /* | |
1018 | * If source and dest are the same, do nothing. | |
1019 | */ | |
1020 | if (tvp == fvp) { | |
1021 | error = 0; | |
1022 | goto abortit; | |
1023 | } | |
1024 | ||
fad57d0e MD |
1025 | /* |
1026 | * fvp, fdvp are unlocked, tvp, tdvp are locked. Lock fvp and note | |
1027 | * that we have to unlock it to use the abortit target. | |
1028 | */ | |
ca466bae | 1029 | error = vn_lock(fvp, LK_EXCLUSIVE); |
984263bc MD |
1030 | if (error) |
1031 | goto abortit; | |
1032 | dp = VTODE(fdvp); | |
1033 | ip = VTODE(fvp); | |
1034 | ||
1035 | /* | |
1036 | * Be sure we are not renaming ".", "..", or an alias of ".". This | |
1037 | * leads to a crippled directory tree. It's pretty tough to do a | |
1038 | * "ls" or "pwd" with the "." directory entry missing, and "cd .." | |
1039 | * doesn't work if the ".." entry is missing. | |
1040 | */ | |
1041 | if (ip->de_Attributes & ATTR_DIRECTORY) { | |
1042 | /* | |
1043 | * Avoid ".", "..", and aliases of "." for obvious reasons. | |
1044 | */ | |
1045 | if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || | |
1046 | dp == ip || | |
2b69e610 MD |
1047 | (fcnp->cn_flags & CNP_ISDOTDOT) || |
1048 | (tcnp->cn_flags & CNP_ISDOTDOT) || | |
984263bc | 1049 | (ip->de_flag & DE_RENAME)) { |
a11aaa81 | 1050 | vn_unlock(fvp); |
984263bc MD |
1051 | error = EINVAL; |
1052 | goto abortit; | |
1053 | } | |
1054 | ip->de_flag |= DE_RENAME; | |
1055 | doingdirectory++; | |
1056 | } | |
1057 | ||
1058 | /* | |
fad57d0e MD |
1059 | * fvp locked, fdvp unlocked, tvp, tdvp locked. DE_RENAME only |
1060 | * set if doingdirectory. We will get fvp unlocked in fairly | |
1061 | * short order. dp and xp must be setup and fvp must be unlocked | |
1062 | * for the out and bad targets to work properly. | |
984263bc MD |
1063 | */ |
1064 | dp = VTODE(tdvp); | |
1065 | xp = tvp ? VTODE(tvp) : NULL; | |
fad57d0e | 1066 | |
984263bc MD |
1067 | /* |
1068 | * Remember direntry place to use for destination | |
1069 | */ | |
1070 | to_diroffset = dp->de_fndoffset; | |
1071 | to_count = dp->de_fndcnt; | |
1072 | ||
1073 | /* | |
1074 | * If ".." must be changed (ie the directory gets a new | |
1075 | * parent) then the source directory must not be in the | |
1076 | * directory heirarchy above the target, as this would | |
1077 | * orphan everything below the source directory. Also | |
1078 | * the user must have write permission in the source so | |
1079 | * as to be able to change "..". We must repeat the call | |
1080 | * to namei, as the parent directory is unlocked by the | |
1081 | * call to doscheckpath(). | |
1082 | */ | |
87de5057 | 1083 | error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred); |
a11aaa81 | 1084 | vn_unlock(fvp); |
984263bc MD |
1085 | if (VTODE(fdvp)->de_StartCluster != VTODE(tdvp)->de_StartCluster) |
1086 | newparent = 1; | |
fad57d0e MD |
1087 | |
1088 | /* | |
1089 | * ok. fvp, fdvp unlocked, tvp, tdvp locked. tvp may be NULL. | |
1090 | * DE_RENAME only set if doingdirectory. | |
1091 | */ | |
984263bc MD |
1092 | if (doingdirectory && newparent) { |
1093 | if (error) /* write access check above */ | |
1094 | goto bad; | |
fad57d0e | 1095 | if (xp != NULL) { |
984263bc | 1096 | vput(tvp); |
fad57d0e MD |
1097 | xp = NULL; |
1098 | } | |
984263bc | 1099 | /* |
fad57d0e MD |
1100 | * checkpath vput's tdvp (VTOI(dp)) on return no matter what, |
1101 | * get an extra ref so we wind up with just an unlocked, ref'd | |
1102 | * tdvp. The 'out' target skips tvp and tdvp cleanups (tdvp | |
1103 | * isn't locked so we can't use the out target). | |
984263bc | 1104 | */ |
fad57d0e | 1105 | vref(tdvp); |
984263bc | 1106 | error = doscheckpath(ip, dp); |
6970b52a | 1107 | tcnp->cn_flags |= CNP_PDIRUNLOCK; |
fad57d0e MD |
1108 | if (error) { |
1109 | vrele(tdvp); | |
984263bc | 1110 | goto out; |
fad57d0e MD |
1111 | } |
1112 | /* | |
1113 | * relookup no longer messes with the ref count. tdvp must | |
1114 | * be unlocked on entry and on success will be locked on | |
1115 | * return. | |
1116 | */ | |
984263bc | 1117 | error = relookup(tdvp, &tvp, tcnp); |
fad57d0e MD |
1118 | if (error) { |
1119 | if (tcnp->cn_flags & CNP_PDIRUNLOCK) | |
1120 | vrele(tdvp); | |
1121 | else | |
1122 | vput(tdvp); | |
984263bc | 1123 | goto out; |
fad57d0e MD |
1124 | } |
1125 | ||
1126 | /* | |
1127 | * tvp and tdvp are now locked again. | |
1128 | */ | |
984263bc MD |
1129 | dp = VTODE(tdvp); |
1130 | xp = tvp ? VTODE(tvp) : NULL; | |
1131 | } | |
1132 | ||
fad57d0e MD |
1133 | /* |
1134 | * tvp and tdvp are now locked again, the 'bad' target can be used | |
1135 | * to clean them up again. Delete an existant target and clean | |
1136 | * up tvp. Set xp to NULL to indicate that tvp has been cleaned up. | |
1137 | */ | |
984263bc MD |
1138 | if (xp != NULL) { |
1139 | /* | |
1140 | * Target must be empty if a directory and have no links | |
1141 | * to it. Also, ensure source and target are compatible | |
1142 | * (both directories, or both not directories). | |
1143 | */ | |
1144 | if (xp->de_Attributes & ATTR_DIRECTORY) { | |
1145 | if (!dosdirempty(xp)) { | |
1146 | error = ENOTEMPTY; | |
1147 | goto bad; | |
1148 | } | |
1149 | if (!doingdirectory) { | |
1150 | error = ENOTDIR; | |
1151 | goto bad; | |
1152 | } | |
984263bc MD |
1153 | } else if (doingdirectory) { |
1154 | error = EISDIR; | |
1155 | goto bad; | |
1156 | } | |
1157 | error = removede(dp, xp); | |
1158 | if (error) | |
1159 | goto bad; | |
1160 | vput(tvp); | |
1161 | xp = NULL; | |
fad57d0e | 1162 | tvp = NULL; |
984263bc MD |
1163 | } |
1164 | ||
1165 | /* | |
1166 | * Convert the filename in tcnp into a dos filename. We copy this | |
1167 | * into the denode and directory entry for the destination | |
1168 | * file/directory. | |
1169 | */ | |
1170 | error = uniqdosname(VTODE(tdvp), tcnp, toname); | |
1171 | if (error) | |
fad57d0e | 1172 | goto bad; |
984263bc MD |
1173 | |
1174 | /* | |
fad57d0e MD |
1175 | * Since from wasn't locked at various places above, we have to do |
1176 | * a relookup here. If the target and source are the same directory | |
1177 | * we have to unlock the target directory in order to safely relookup | |
1178 | * the source, because relookup expects its directory to be unlocked. | |
1179 | * | |
1180 | * Note that ap->a_fvp is still valid and ref'd. Any cleanup must | |
1181 | * now take that into account. | |
1182 | * | |
1183 | * The tdvp locking issues make this a real mess. | |
984263bc | 1184 | */ |
2b69e610 | 1185 | fcnp->cn_flags &= ~CNP_MODMASK; |
fad57d0e MD |
1186 | fcnp->cn_flags |= CNP_LOCKPARENT; |
1187 | if (newparent == 0) | |
a11aaa81 | 1188 | vn_unlock(tdvp); |
fad57d0e MD |
1189 | error = relookup(fdvp, &fvp, fcnp); |
1190 | if (error || fvp == NULL) { | |
984263bc | 1191 | /* |
fad57d0e MD |
1192 | * From name has disappeared. Note: fdvp might == tdvp. |
1193 | * | |
1194 | * DE_RENAME is only set if doingdirectory. | |
984263bc MD |
1195 | */ |
1196 | if (doingdirectory) | |
1197 | panic("rename: lost dir entry"); | |
fad57d0e MD |
1198 | if (fcnp->cn_flags & CNP_PDIRUNLOCK) |
1199 | vrele(fdvp); | |
1200 | else | |
1201 | vput(fdvp); | |
1202 | if (newparent == 0) | |
1203 | vrele(tdvp); | |
1204 | else | |
1205 | vput(tdvp); | |
984263bc | 1206 | vrele(ap->a_fvp); |
fad57d0e | 1207 | return(0); |
984263bc | 1208 | } |
fad57d0e MD |
1209 | |
1210 | /* | |
1211 | * No error occured. tdvp, fdvp and fvp are all locked. If | |
1212 | * newparent was 0 be aware that fdvp == tdvp. tvp has been cleaned | |
1213 | * up. ap->a_fvp is still refd. | |
1214 | */ | |
984263bc MD |
1215 | xp = VTODE(fvp); |
1216 | zp = VTODE(fdvp); | |
1217 | from_diroffset = zp->de_fndoffset; | |
1218 | ||
1219 | /* | |
1220 | * Ensure that the directory entry still exists and has not | |
1221 | * changed till now. If the source is a file the entry may | |
1222 | * have been unlinked or renamed. In either case there is | |
1223 | * no further work to be done. If the source is a directory | |
1224 | * then it cannot have been rmdir'ed or renamed; this is | |
1225 | * prohibited by the DE_RENAME flag. | |
fad57d0e MD |
1226 | * |
1227 | * DE_RENAME is only set if doingdirectory. | |
984263bc MD |
1228 | */ |
1229 | if (xp != ip) { | |
1230 | if (doingdirectory) | |
1231 | panic("rename: lost dir entry"); | |
fad57d0e | 1232 | goto done; |
984263bc | 1233 | } else { |
3446c007 MD |
1234 | u_long new_dirclust; |
1235 | u_long new_diroffset; | |
1236 | ||
984263bc MD |
1237 | /* |
1238 | * First write a new entry in the destination | |
1239 | * directory and mark the entry in the source directory | |
1240 | * as deleted. Then move the denode to the correct hash | |
1241 | * chain for its new location in the filesystem. And, if | |
1242 | * we moved a directory, then update its .. entry to point | |
1243 | * to the new parent directory. | |
1244 | */ | |
1245 | bcopy(ip->de_Name, oldname, 11); | |
1246 | bcopy(toname, ip->de_Name, 11); /* update denode */ | |
1247 | dp->de_fndoffset = to_diroffset; | |
1248 | dp->de_fndcnt = to_count; | |
60233e58 | 1249 | error = createde(ip, dp, NULL, tcnp); |
984263bc MD |
1250 | if (error) { |
1251 | bcopy(oldname, ip->de_Name, 11); | |
fad57d0e | 1252 | goto done; |
984263bc MD |
1253 | } |
1254 | ip->de_refcnt++; | |
1255 | zp->de_fndoffset = from_diroffset; | |
1256 | error = removede(zp, ip); | |
1257 | if (error) { | |
1258 | /* XXX should really panic here, fs is corrupt */ | |
fad57d0e | 1259 | goto done; |
984263bc MD |
1260 | } |
1261 | if (!doingdirectory) { | |
4afd80f1 MD |
1262 | error = pcbmap(dp, de_cluster(pmp, to_diroffset), |
1263 | NULL, &new_dirclust, NULL); | |
984263bc MD |
1264 | if (error) { |
1265 | /* XXX should really panic here, fs is corrupt */ | |
fad57d0e | 1266 | goto done; |
984263bc | 1267 | } |
3446c007 MD |
1268 | if (new_dirclust == MSDOSFSROOT) |
1269 | new_diroffset = to_diroffset; | |
984263bc | 1270 | else |
3446c007 MD |
1271 | new_diroffset = to_diroffset & pmp->pm_crbomask; |
1272 | msdosfs_reinsert(ip, new_dirclust, new_diroffset); | |
984263bc | 1273 | } |
984263bc MD |
1274 | } |
1275 | ||
1276 | /* | |
1277 | * If we moved a directory to a new parent directory, then we must | |
1278 | * fixup the ".." entry in the moved directory. | |
1279 | */ | |
1280 | if (doingdirectory && newparent) { | |
1281 | cn = ip->de_StartCluster; | |
1282 | if (cn == MSDOSFSROOT) { | |
1283 | /* this should never happen */ | |
1284 | panic("msdosfs_rename(): updating .. in root directory?"); | |
fad57d0e | 1285 | } else { |
4afd80f1 | 1286 | bn = xcntobn(pmp, cn); |
fad57d0e | 1287 | } |
54078292 | 1288 | error = bread(pmp->pm_devvp, de_bntodoff(pmp, bn), pmp->pm_bpcluster, &bp); |
984263bc MD |
1289 | if (error) { |
1290 | /* XXX should really panic here, fs is corrupt */ | |
1291 | brelse(bp); | |
fad57d0e | 1292 | goto done; |
984263bc MD |
1293 | } |
1294 | dotdotp = (struct direntry *)bp->b_data + 1; | |
1295 | putushort(dotdotp->deStartCluster, dp->de_StartCluster); | |
1296 | if (FAT32(pmp)) | |
1297 | putushort(dotdotp->deHighClust, dp->de_StartCluster >> 16); | |
1298 | error = bwrite(bp); | |
1299 | if (error) { | |
1300 | /* XXX should really panic here, fs is corrupt */ | |
fad57d0e | 1301 | goto done; |
984263bc MD |
1302 | } |
1303 | } | |
1304 | ||
fad57d0e MD |
1305 | /* |
1306 | * done case fvp, fdvp, tdvp are locked. ap->a_fvp is refd | |
1307 | */ | |
1308 | done: | |
1309 | if (doingdirectory) | |
1310 | ip->de_flag &= ~DE_RENAME; /* XXX fvp not locked */ | |
1311 | vput(fvp); | |
1312 | if (newparent) | |
1313 | vput(fdvp); | |
1314 | else | |
1315 | vrele(fdvp); | |
1316 | vput(tdvp); | |
1317 | vrele(ap->a_fvp); | |
1318 | return (error); | |
1319 | ||
1320 | /* | |
1321 | * 'bad' target: xp governs tvp. tvp and tdvp arel ocked, fdvp and fvp | |
1322 | * are not locked. ip points to fvp's inode which may have DE_RENAME | |
1323 | * set. | |
1324 | */ | |
984263bc MD |
1325 | bad: |
1326 | if (xp) | |
1327 | vput(tvp); | |
1328 | vput(tdvp); | |
1329 | out: | |
fad57d0e MD |
1330 | /* |
1331 | * 'out' target: tvp and tdvp have already been cleaned up. | |
1332 | */ | |
1333 | if (doingdirectory) | |
1334 | ip->de_flag &= ~DE_RENAME; | |
984263bc MD |
1335 | vrele(fdvp); |
1336 | vrele(fvp); | |
1337 | return (error); | |
1338 | ||
1339 | } | |
1340 | ||
1341 | static struct { | |
1342 | struct direntry dot; | |
1343 | struct direntry dotdot; | |
1344 | } dosdirtemplate = { | |
1345 | { ". ", " ", /* the . entry */ | |
1346 | ATTR_DIRECTORY, /* file attribute */ | |
1347 | 0, /* reserved */ | |
1348 | 0, { 0, 0 }, { 0, 0 }, /* create time & date */ | |
1349 | { 0, 0 }, /* access date */ | |
1350 | { 0, 0 }, /* high bits of start cluster */ | |
1351 | { 210, 4 }, { 210, 4 }, /* modify time & date */ | |
1352 | { 0, 0 }, /* startcluster */ | |
1353 | { 0, 0, 0, 0 } /* filesize */ | |
1354 | }, | |
1355 | { ".. ", " ", /* the .. entry */ | |
1356 | ATTR_DIRECTORY, /* file attribute */ | |
1357 | 0, /* reserved */ | |
1358 | 0, { 0, 0 }, { 0, 0 }, /* create time & date */ | |
1359 | { 0, 0 }, /* access date */ | |
1360 | { 0, 0 }, /* high bits of start cluster */ | |
1361 | { 210, 4 }, { 210, 4 }, /* modify time & date */ | |
1362 | { 0, 0 }, /* startcluster */ | |
1363 | { 0, 0, 0, 0 } /* filesize */ | |
1364 | } | |
1365 | }; | |
1366 | ||
4625f023 CP |
1367 | /* |
1368 | * msdosfs_mkdir(struct vnode *a_dvp, struct vnode **a_vpp, | |
1369 | * struct componentname *a_cnp, struct vattr *a_vap) | |
1370 | */ | |
984263bc | 1371 | static int |
e62afb5f | 1372 | msdosfs_mkdir(struct vop_old_mkdir_args *ap) |
984263bc MD |
1373 | { |
1374 | struct componentname *cnp = ap->a_cnp; | |
1375 | struct denode *dep; | |
1376 | struct denode *pdep = VTODE(ap->a_dvp); | |
1377 | struct direntry *denp; | |
1378 | struct msdosfsmount *pmp = pdep->de_pmp; | |
1379 | struct buf *bp; | |
1380 | u_long newcluster, pcl; | |
1381 | int bn; | |
1382 | int error; | |
1383 | struct denode ndirent; | |
1384 | struct timespec ts; | |
1385 | ||
1386 | /* | |
1387 | * If this is the root directory and there is no space left we | |
1388 | * can't do anything. This is because the root directory can not | |
1389 | * change size. | |
1390 | */ | |
1391 | if (pdep->de_StartCluster == MSDOSFSROOT | |
1392 | && pdep->de_fndoffset >= pdep->de_FileSize) { | |
1393 | error = ENOSPC; | |
1394 | goto bad2; | |
1395 | } | |
1396 | ||
1397 | /* | |
1398 | * Allocate a cluster to hold the about to be created directory. | |
1399 | */ | |
1400 | error = clusteralloc(pmp, 0, 1, CLUST_EOFE, &newcluster, NULL); | |
1401 | if (error) | |
1402 | goto bad2; | |
1403 | ||
1404 | bzero(&ndirent, sizeof(ndirent)); | |
1405 | ndirent.de_pmp = pmp; | |
1406 | ndirent.de_flag = DE_ACCESS | DE_CREATE | DE_UPDATE; | |
1407 | getnanotime(&ts); | |
1408 | DETIMES(&ndirent, &ts, &ts, &ts); | |
1409 | ||
1410 | /* | |
1411 | * Now fill the cluster with the "." and ".." entries. And write | |
1412 | * the cluster to disk. This way it is there for the parent | |
1413 | * directory to be pointing at if there were a crash. | |
1414 | */ | |
4afd80f1 | 1415 | bn = xcntobn(pmp, newcluster); |
984263bc | 1416 | /* always succeeds */ |
54078292 MD |
1417 | bp = getblk(pmp->pm_devvp, de_bntodoff(pmp, bn), |
1418 | pmp->pm_bpcluster, 0, 0); | |
984263bc MD |
1419 | bzero(bp->b_data, pmp->pm_bpcluster); |
1420 | bcopy(&dosdirtemplate, bp->b_data, sizeof dosdirtemplate); | |
1421 | denp = (struct direntry *)bp->b_data; | |
1422 | putushort(denp[0].deStartCluster, newcluster); | |
1423 | putushort(denp[0].deCDate, ndirent.de_CDate); | |
1424 | putushort(denp[0].deCTime, ndirent.de_CTime); | |
1425 | denp[0].deCHundredth = ndirent.de_CHun; | |
1426 | putushort(denp[0].deADate, ndirent.de_ADate); | |
1427 | putushort(denp[0].deMDate, ndirent.de_MDate); | |
1428 | putushort(denp[0].deMTime, ndirent.de_MTime); | |
1429 | pcl = pdep->de_StartCluster; | |
1430 | if (FAT32(pmp) && pcl == pmp->pm_rootdirblk) | |
1431 | pcl = 0; | |
1432 | putushort(denp[1].deStartCluster, pcl); | |
1433 | putushort(denp[1].deCDate, ndirent.de_CDate); | |
1434 | putushort(denp[1].deCTime, ndirent.de_CTime); | |
1435 | denp[1].deCHundredth = ndirent.de_CHun; | |
1436 | putushort(denp[1].deADate, ndirent.de_ADate); | |
1437 | putushort(denp[1].deMDate, ndirent.de_MDate); | |
1438 | putushort(denp[1].deMTime, ndirent.de_MTime); | |
1439 | if (FAT32(pmp)) { | |
1440 | putushort(denp[0].deHighClust, newcluster >> 16); | |
1441 | putushort(denp[1].deHighClust, pdep->de_StartCluster >> 16); | |
1442 | } | |
1443 | ||
1444 | error = bwrite(bp); | |
1445 | if (error) | |
1446 | goto bad; | |
1447 | ||
1448 | /* | |
1449 | * Now build up a directory entry pointing to the newly allocated | |
1450 | * cluster. This will be written to an empty slot in the parent | |
1451 | * directory. | |
1452 | */ | |
984263bc MD |
1453 | error = uniqdosname(pdep, cnp, ndirent.de_Name); |
1454 | if (error) | |
1455 | goto bad; | |
1456 | ||
1457 | ndirent.de_Attributes = ATTR_DIRECTORY; | |
1458 | ndirent.de_LowerCase = 0; | |
1459 | ndirent.de_StartCluster = newcluster; | |
1460 | ndirent.de_FileSize = 0; | |
1461 | ndirent.de_dev = pdep->de_dev; | |
1462 | ndirent.de_devvp = pdep->de_devvp; | |
1463 | error = createde(&ndirent, pdep, &dep, cnp); | |
1464 | if (error) | |
1465 | goto bad; | |
1466 | *ap->a_vpp = DETOV(dep); | |
1467 | return (0); | |
1468 | ||
1469 | bad: | |
1470 | clusterfree(pmp, newcluster, NULL); | |
1471 | bad2: | |
1472 | return (error); | |
1473 | } | |
1474 | ||
4625f023 CP |
1475 | /* |
1476 | * msdosfs_rmdir(struct vnode *a_dvp, struct vnode *a_vp, | |
1477 | * struct componentname *a_cnp) | |
1478 | */ | |
984263bc | 1479 | static int |
e62afb5f | 1480 | msdosfs_rmdir(struct vop_old_rmdir_args *ap) |
984263bc | 1481 | { |
dadab5e9 MD |
1482 | struct vnode *vp = ap->a_vp; |
1483 | struct vnode *dvp = ap->a_dvp; | |
dadab5e9 | 1484 | struct denode *ip, *dp; |
984263bc MD |
1485 | int error; |
1486 | ||
1487 | ip = VTODE(vp); | |
1488 | dp = VTODE(dvp); | |
1489 | ||
1490 | /* | |
1491 | * Verify the directory is empty (and valid). | |
1492 | * (Rmdir ".." won't be valid since | |
1493 | * ".." will contain a reference to | |
1494 | * the current directory and thus be | |
1495 | * non-empty.) | |
1496 | */ | |
1497 | error = 0; | |
1498 | if (!dosdirempty(ip) || ip->de_flag & DE_RENAME) { | |
1499 | error = ENOTEMPTY; | |
1500 | goto out; | |
1501 | } | |
1502 | /* | |
1503 | * Delete the entry from the directory. For dos filesystems this | |
1504 | * gets rid of the directory entry on disk, the in memory copy | |
1505 | * still exists but the de_refcnt is <= 0. This prevents it from | |
1506 | * being found by deget(). When the vput() on dep is done we give | |
1507 | * up access and eventually msdosfs_reclaim() will be called which | |
1508 | * will remove it from the denode cache. | |
1509 | */ | |
1510 | error = removede(dp, ip); | |
1511 | if (error) | |
1512 | goto out; | |
1513 | /* | |
1514 | * This is where we decrement the link count in the parent | |
1515 | * directory. Since dos filesystems don't do this we just purge | |
1516 | * the name cache. | |
1517 | */ | |
a11aaa81 | 1518 | vn_unlock(dvp); |
984263bc MD |
1519 | /* |
1520 | * Truncate the directory that is being deleted. | |
1521 | */ | |
87de5057 | 1522 | error = detrunc(ip, (u_long)0, IO_SYNC); |
984263bc | 1523 | |
ca466bae | 1524 | vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); |
984263bc MD |
1525 | out: |
1526 | return (error); | |
1527 | } | |
1528 | ||
1529 | /* | |
1530 | * DOS filesystems don't know what symlinks are. | |
4625f023 CP |
1531 | * |
1532 | * msdosfs_symlink(struct vnode *a_dvp, struct vnode **a_vpp, | |
1533 | * struct componentname *a_cnp, struct vattr *a_vap, | |
1534 | * char *a_target) | |
984263bc MD |
1535 | */ |
1536 | static int | |
e62afb5f | 1537 | msdosfs_symlink(struct vop_old_symlink_args *ap) |
984263bc MD |
1538 | { |
1539 | return (EOPNOTSUPP); | |
1540 | } | |
1541 | ||
4625f023 CP |
1542 | /* |
1543 | * msdosfs_readdir(struct vnode *a_vp, struct uio *a_uio, | |
1544 | * struct ucred *a_cred, int *a_eofflag, int *a_ncookies, | |
84009d92 | 1545 | * off_t **a_cookies) |
4625f023 | 1546 | */ |
984263bc | 1547 | static int |
4625f023 | 1548 | msdosfs_readdir(struct vop_readdir_args *ap) |
984263bc MD |
1549 | { |
1550 | int error = 0; | |
1551 | int diff; | |
1552 | long n; | |
1553 | int blsize; | |
1554 | long on; | |
1555 | u_long cn; | |
984263bc MD |
1556 | u_long dirsperblk; |
1557 | long bias = 0; | |
1558 | daddr_t bn, lbn; | |
1559 | struct buf *bp; | |
885ecb13 MD |
1560 | struct denode *dep; |
1561 | struct msdosfsmount *pmp; | |
984263bc | 1562 | struct direntry *dentp; |
984263bc | 1563 | struct uio *uio = ap->a_uio; |
84009d92 | 1564 | off_t *cookies = NULL; |
984263bc MD |
1565 | int ncookies = 0; |
1566 | off_t offset, off; | |
1567 | int chksum = -1; | |
1754e0da JS |
1568 | ino_t d_ino; |
1569 | uint16_t d_namlen; | |
1570 | uint8_t d_type; | |
1571 | char *d_name_storage = NULL; | |
1572 | char *d_name; | |
984263bc | 1573 | |
885ecb13 MD |
1574 | if ((error = vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY)) != 0) |
1575 | return (error); | |
1576 | ||
1577 | dep = VTODE(ap->a_vp); | |
1578 | pmp = dep->de_pmp; | |
1579 | ||
984263bc | 1580 | #ifdef MSDOSFS_DEBUG |
086c1d7e | 1581 | kprintf("msdosfs_readdir(): vp %p, uio %p, cred %p, eofflagp %p\n", |
984263bc MD |
1582 | ap->a_vp, uio, ap->a_cred, ap->a_eofflag); |
1583 | #endif | |
1584 | ||
1585 | /* | |
1586 | * msdosfs_readdir() won't operate properly on regular files since | |
1587 | * it does i/o only with the the filesystem vnode, and hence can | |
1588 | * retrieve the wrong block from the buffer cache for a plain file. | |
1589 | * So, fail attempts to readdir() on a plain file. | |
1590 | */ | |
885ecb13 MD |
1591 | if ((dep->de_Attributes & ATTR_DIRECTORY) == 0) { |
1592 | error = ENOTDIR; | |
1593 | goto done; | |
1594 | } | |
984263bc | 1595 | |
984263bc MD |
1596 | /* |
1597 | * If the user buffer is smaller than the size of one dos directory | |
1598 | * entry or the file offset is not a multiple of the size of a | |
1599 | * directory entry, then we fail the read. | |
1600 | */ | |
1601 | off = offset = uio->uio_offset; | |
1602 | if (uio->uio_resid < sizeof(struct direntry) || | |
885ecb13 MD |
1603 | (offset & (sizeof(struct direntry) - 1))) { |
1604 | error = EINVAL; | |
1605 | goto done; | |
1606 | } | |
984263bc MD |
1607 | |
1608 | if (ap->a_ncookies) { | |
fb0466c9 MD |
1609 | ncookies = uio->uio_resid / 16 + 1; |
1610 | if (ncookies > 1024) | |
1611 | ncookies = 1024; | |
84009d92 | 1612 | MALLOC(cookies, off_t *, ncookies * sizeof(off_t), M_TEMP, |
984263bc MD |
1613 | M_WAITOK); |
1614 | *ap->a_cookies = cookies; | |
1615 | *ap->a_ncookies = ncookies; | |
1616 | } | |
1617 | ||
1618 | dirsperblk = pmp->pm_BytesPerSec / sizeof(struct direntry); | |
1619 | ||
1620 | /* | |
1621 | * If they are reading from the root directory then, we simulate | |
1622 | * the . and .. entries since these don't exist in the root | |
1623 | * directory. We also set the offset bias to make up for having to | |
1624 | * simulate these entries. By this I mean that at file offset 64 we | |
1625 | * read the first entry in the root directory that lives on disk. | |
1626 | */ | |
1627 | if (dep->de_StartCluster == MSDOSFSROOT | |
1628 | || (FAT32(pmp) && dep->de_StartCluster == pmp->pm_rootdirblk)) { | |
1629 | #if 0 | |
086c1d7e | 1630 | kprintf("msdosfs_readdir(): going after . or .. in root dir, offset %d\n", |
984263bc MD |
1631 | offset); |
1632 | #endif | |
1633 | bias = 2 * sizeof(struct direntry); | |
1634 | if (offset < bias) { | |
1754e0da JS |
1635 | for (n = (int)offset / sizeof(struct direntry); n < 2; |
1636 | n++) { | |
984263bc | 1637 | if (FAT32(pmp)) |
4afd80f1 | 1638 | d_ino = xcntobn(pmp, pmp->pm_rootdirblk) |
1754e0da | 1639 | * dirsperblk; |
984263bc | 1640 | else |
1754e0da JS |
1641 | d_ino = 1; |
1642 | d_type = DT_DIR; | |
1643 | if (n == 0) { | |
1644 | d_namlen = 1; | |
1645 | d_name = "."; | |
1646 | } else /* if (n == 1) */{ | |
1647 | d_namlen = 2; | |
1648 | d_name = ".."; | |
984263bc | 1649 | } |
1754e0da JS |
1650 | if (vop_write_dirent(&error, uio, d_ino, d_type, |
1651 | d_namlen, d_name)) | |
984263bc | 1652 | goto out; |
984263bc MD |
1653 | if (error) |
1654 | goto out; | |
1655 | offset += sizeof(struct direntry); | |
1656 | off = offset; | |
1657 | if (cookies) { | |
1658 | *cookies++ = offset; | |
1659 | if (--ncookies <= 0) | |
1660 | goto out; | |
1661 | } | |
1662 | } | |
1663 | } | |
1664 | } | |
1665 | ||
efda3bd0 | 1666 | d_name_storage = kmalloc(WIN_MAXLEN, M_TEMP, M_WAITOK); |
984263bc | 1667 | off = offset; |
1754e0da | 1668 | |
984263bc | 1669 | while (uio->uio_resid > 0) { |
4afd80f1 | 1670 | lbn = de_off2cn(pmp, offset - bias); |
984263bc | 1671 | on = (offset - bias) & pmp->pm_crbomask; |
e54488bb | 1672 | n = szmin(pmp->pm_bpcluster - on, uio->uio_resid); |
984263bc MD |
1673 | diff = dep->de_FileSize - (offset - bias); |
1674 | if (diff <= 0) | |
1675 | break; | |
1676 | n = min(n, diff); | |
1677 | error = pcbmap(dep, lbn, &bn, &cn, &blsize); | |
1678 | if (error) | |
1679 | break; | |
54078292 | 1680 | error = bread(pmp->pm_devvp, de_bntodoff(pmp, bn), blsize, &bp); |
984263bc MD |
1681 | if (error) { |
1682 | brelse(bp); | |
efda3bd0 | 1683 | kfree(d_name_storage, M_TEMP); |
885ecb13 | 1684 | goto done; |
984263bc MD |
1685 | } |
1686 | n = min(n, blsize - bp->b_resid); | |
1687 | ||
1688 | /* | |
1689 | * Convert from dos directory entries to fs-independent | |
1690 | * directory entries. | |
1691 | */ | |
1692 | for (dentp = (struct direntry *)(bp->b_data + on); | |
1693 | (char *)dentp < bp->b_data + on + n; | |
1694 | dentp++, offset += sizeof(struct direntry)) { | |
1695 | #if 0 | |
086c1d7e | 1696 | kprintf("rd: dentp %08x prev %08x crnt %08x deName %02x attr %02x\n", |
984263bc MD |
1697 | dentp, prev, crnt, dentp->deName[0], dentp->deAttributes); |
1698 | #endif | |
1754e0da | 1699 | d_name = d_name_storage; |
984263bc MD |
1700 | /* |
1701 | * If this is an unused entry, we can stop. | |
1702 | */ | |
1703 | if (dentp->deName[0] == SLOT_EMPTY) { | |
1704 | brelse(bp); | |
1705 | goto out; | |
1706 | } | |
1707 | /* | |
1708 | * Skip deleted entries. | |
1709 | */ | |
1710 | if (dentp->deName[0] == SLOT_DELETED) { | |
1711 | chksum = -1; | |
1712 | continue; | |
1713 | } | |
1714 | ||
1715 | /* | |
1716 | * Handle Win95 long directory entries | |
1717 | */ | |
1718 | if (dentp->deAttributes == ATTR_WIN95) { | |
1719 | if (pmp->pm_flags & MSDOSFSMNT_SHORTNAME) | |
1720 | continue; | |
1721 | chksum = win2unixfn((struct winentry *)dentp, | |
1754e0da | 1722 | d_name, &d_namlen, chksum, |
984263bc MD |
1723 | pmp->pm_flags & MSDOSFSMNT_U2WTABLE, |
1724 | pmp->pm_u2w); | |
1725 | continue; | |
1726 | } | |
1727 | ||
1728 | /* | |
1729 | * Skip volume labels | |
1730 | */ | |
1731 | if (dentp->deAttributes & ATTR_VOLUME) { | |
1732 | chksum = -1; | |
1733 | continue; | |
1734 | } | |
1735 | /* | |
1754e0da | 1736 | * This computation of d_ino must match |
984263bc MD |
1737 | * the computation of va_fileid in |
1738 | * msdosfs_getattr. | |
1739 | */ | |
1740 | if (dentp->deAttributes & ATTR_DIRECTORY) { | |
1754e0da | 1741 | d_ino = getushort(dentp->deStartCluster); |
984263bc | 1742 | if (FAT32(pmp)) |
1754e0da | 1743 | d_ino |= getushort(dentp->deHighClust) << 16; |
984263bc | 1744 | /* if this is the root directory */ |
1754e0da | 1745 | if (d_ino != MSDOSFSROOT) |
4afd80f1 | 1746 | d_ino = xcntobn(pmp, d_ino) * dirsperblk; |
1754e0da | 1747 | else if (FAT32(pmp)) |
4afd80f1 | 1748 | d_ino = xcntobn(pmp, pmp->pm_rootdirblk) |
1754e0da | 1749 | * dirsperblk; |
984263bc | 1750 | else |
1754e0da JS |
1751 | d_ino = 1; |
1752 | d_type = DT_DIR; | |
984263bc | 1753 | } else { |
1754e0da JS |
1754 | d_ino = offset / sizeof(struct direntry); |
1755 | d_type = DT_REG; | |
984263bc | 1756 | } |
1754e0da JS |
1757 | if (chksum != winChksum(dentp->deName)) { |
1758 | d_namlen = dos2unixfn(dentp->deName, | |
1759 | (u_char *)d_name, | |
984263bc MD |
1760 | dentp->deLowerCase | |
1761 | ((pmp->pm_flags & MSDOSFSMNT_SHORTNAME) ? | |
1762 | (LCASE_BASE | LCASE_EXT) : 0), | |
1763 | pmp->pm_flags & MSDOSFSMNT_U2WTABLE, | |
1764 | pmp->pm_d2u, | |
1765 | pmp->pm_flags & MSDOSFSMNT_ULTABLE, | |
1766 | pmp->pm_ul); | |
1754e0da | 1767 | } |
984263bc | 1768 | chksum = -1; |
1754e0da JS |
1769 | if (vop_write_dirent(&error, uio, d_ino, d_type, |
1770 | d_namlen, d_name)) { | |
984263bc MD |
1771 | brelse(bp); |
1772 | goto out; | |
1773 | } | |
984263bc MD |
1774 | if (error) { |
1775 | brelse(bp); | |
1776 | goto out; | |
1777 | } | |
1754e0da | 1778 | |
984263bc MD |
1779 | if (cookies) { |
1780 | *cookies++ = offset + sizeof(struct direntry); | |
1781 | if (--ncookies <= 0) { | |
1782 | brelse(bp); | |
1783 | goto out; | |
1784 | } | |
1785 | } | |
1786 | off = offset + sizeof(struct direntry); | |
1787 | } | |
1788 | brelse(bp); | |
1789 | } | |
1790 | out: | |
1754e0da | 1791 | if (d_name_storage != NULL) |
efda3bd0 | 1792 | kfree(d_name_storage, M_TEMP); |
1754e0da | 1793 | |
984263bc MD |
1794 | /* Subtract unused cookies */ |
1795 | if (ap->a_ncookies) | |
1796 | *ap->a_ncookies -= ncookies; | |
1797 | ||
1798 | uio->uio_offset = off; | |
1799 | ||
1800 | /* | |
1801 | * Set the eofflag (NFS uses it) | |
1802 | */ | |
1803 | if (ap->a_eofflag) { | |
1804 | if (dep->de_FileSize - (offset - bias) <= 0) | |
1805 | *ap->a_eofflag = 1; | |
1806 | else | |
1807 | *ap->a_eofflag = 0; | |
1808 | } | |
885ecb13 MD |
1809 | done: |
1810 | vn_unlock(ap->a_vp); | |
984263bc MD |
1811 | return (error); |
1812 | } | |
1813 | ||
1814 | /* | |
1815 | * vp - address of vnode file the file | |
1816 | * bn - which cluster we are interested in mapping to a filesystem block number. | |
1817 | * vpp - returns the vnode for the block special file holding the filesystem | |
1818 | * containing the file of interest | |
1819 | * bnp - address of where to return the filesystem relative block number | |
4625f023 | 1820 | * |
08daea96 | 1821 | * msdosfs_bmap(struct vnode *a_vp, off_t a_loffset, |
54078292 | 1822 | * off_t *a_doffsetp, int *a_runp, int *a_runb) |
984263bc MD |
1823 | */ |
1824 | static int | |
4625f023 | 1825 | msdosfs_bmap(struct vop_bmap_args *ap) |
984263bc MD |
1826 | { |
1827 | struct denode *dep = VTODE(ap->a_vp); | |
54078292 MD |
1828 | struct msdosfsmount *pmp = dep->de_pmp; |
1829 | daddr_t lbn; | |
1830 | daddr_t dbn; | |
1831 | int error; | |
984263bc | 1832 | |
54078292 | 1833 | if (ap->a_doffsetp == NULL) |
984263bc MD |
1834 | return (0); |
1835 | if (ap->a_runp) { | |
1836 | /* | |
1837 | * Sequential clusters should be counted here. | |
1838 | */ | |
1839 | *ap->a_runp = 0; | |
1840 | } | |
1841 | if (ap->a_runb) { | |
1842 | *ap->a_runb = 0; | |
1843 | } | |
4afd80f1 MD |
1844 | KKASSERT(((int)ap->a_loffset & ((1 << pmp->pm_cnshift) - 1)) == 0); |
1845 | lbn = de_off2cn(pmp, ap->a_loffset); | |
1846 | error = pcbmap(dep, lbn, &dbn, NULL, NULL); | |
54078292 MD |
1847 | if (error || dbn == (daddr_t)-1) { |
1848 | *ap->a_doffsetp = NOOFFSET; | |
1849 | } else { | |
4afd80f1 | 1850 | *ap->a_doffsetp = de_bntodoff(pmp, dbn); |
54078292 MD |
1851 | } |
1852 | return (error); | |
984263bc MD |
1853 | } |
1854 | ||
4625f023 | 1855 | /* |
81b5c339 | 1856 | * msdosfs_strategy(struct vnode *a_vp, struct bio *a_bio) |
4625f023 | 1857 | */ |
984263bc | 1858 | static int |
4625f023 | 1859 | msdosfs_strategy(struct vop_strategy_args *ap) |
984263bc | 1860 | { |
81b5c339 MD |
1861 | struct bio *bio = ap->a_bio; |
1862 | struct bio *nbio; | |
1863 | struct buf *bp = bio->bio_buf; | |
1864 | struct vnode *vp = ap->a_vp; | |
1865 | struct denode *dep = VTODE(vp); | |
54078292 | 1866 | struct msdosfsmount *pmp = dep->de_pmp; |
984263bc | 1867 | int error = 0; |
54078292 | 1868 | daddr_t dblkno; |
984263bc | 1869 | |
81b5c339 | 1870 | if (vp->v_type == VBLK || vp->v_type == VCHR) |
984263bc MD |
1871 | panic("msdosfs_strategy: spec"); |
1872 | /* | |
1873 | * If we don't already know the filesystem relative block number | |
1874 | * then get it using pcbmap(). If pcbmap() returns the block | |
1875 | * number as -1 then we've got a hole in the file. DOS filesystems | |
1876 | * don't allow files with holes, so we shouldn't ever see this. | |
1877 | */ | |
81b5c339 | 1878 | nbio = push_bio(bio); |
54078292 | 1879 | if (nbio->bio_offset == NOOFFSET) { |
4afd80f1 MD |
1880 | error = pcbmap(dep, de_off2cn(pmp, bio->bio_offset), |
1881 | &dblkno, NULL, NULL); | |
984263bc MD |
1882 | if (error) { |
1883 | bp->b_error = error; | |
1884 | bp->b_flags |= B_ERROR; | |
81b5c339 MD |
1885 | /* I/O was never started on nbio, must biodone(bio) */ |
1886 | biodone(bio); | |
984263bc MD |
1887 | return (error); |
1888 | } | |
54078292 MD |
1889 | if (dblkno == (daddr_t)-1) { |
1890 | nbio->bio_offset = NOOFFSET; | |
984263bc | 1891 | vfs_bio_clrbuf(bp); |
54078292 | 1892 | } else { |
4afd80f1 | 1893 | nbio->bio_offset = de_bntodoff(pmp, dblkno); |
54078292 | 1894 | } |
984263bc | 1895 | } |
54078292 | 1896 | if (nbio->bio_offset == NOOFFSET) { |
81b5c339 MD |
1897 | /* I/O was never started on nbio, must biodone(bio) */ |
1898 | biodone(bio); | |
984263bc MD |
1899 | return (0); |
1900 | } | |
1901 | /* | |
1902 | * Read/write the block from/to the disk that contains the desired | |
1903 | * file block. | |
1904 | */ | |
81b5c339 | 1905 | vn_strategy(dep->de_devvp, nbio); |
984263bc MD |
1906 | return (0); |
1907 | } | |
1908 | ||
4625f023 CP |
1909 | /* |
1910 | * msdosfs_print(struct vnode *vp) | |
1911 | */ | |
984263bc | 1912 | static int |
4625f023 | 1913 | msdosfs_print(struct vop_print_args *ap) |
984263bc MD |
1914 | { |
1915 | struct denode *dep = VTODE(ap->a_vp); | |
1916 | ||
086c1d7e | 1917 | kprintf( |
984263bc MD |
1918 | "tag VT_MSDOSFS, startcluster %lu, dircluster %lu, diroffset %lu ", |
1919 | dep->de_StartCluster, dep->de_dirclust, dep->de_diroffset); | |
086c1d7e | 1920 | kprintf(" dev %d, %d", major(dep->de_dev), minor(dep->de_dev)); |
3446c007 | 1921 | lockmgr_printinfo(&ap->a_vp->v_lock); |
086c1d7e | 1922 | kprintf("\n"); |
984263bc MD |
1923 | return (0); |
1924 | } | |
1925 | ||
4625f023 CP |
1926 | /* |
1927 | * msdosfs_pathconf(struct vnode *a_vp, int a_name, int *a_retval) | |
1928 | */ | |
984263bc | 1929 | static int |
4625f023 | 1930 | msdosfs_pathconf(struct vop_pathconf_args *ap) |
984263bc MD |
1931 | { |
1932 | struct msdosfsmount *pmp = VTODE(ap->a_vp)->de_pmp; | |
1933 | ||
1934 | switch (ap->a_name) { | |
1935 | case _PC_LINK_MAX: | |
1936 | *ap->a_retval = 1; | |
1937 | return (0); | |
1938 | case _PC_NAME_MAX: | |
1939 | *ap->a_retval = pmp->pm_flags & MSDOSFSMNT_LONGNAME ? WIN_MAXLEN : 12; | |
1940 | return (0); | |
1941 | case _PC_PATH_MAX: | |
1942 | *ap->a_retval = PATH_MAX; | |
1943 | return (0); | |
1944 | case _PC_CHOWN_RESTRICTED: | |
1945 | *ap->a_retval = 1; | |
1946 | return (0); | |
1947 | case _PC_NO_TRUNC: | |
1948 | *ap->a_retval = 0; | |
1949 | return (0); | |
1950 | default: | |
1951 | return (EINVAL); | |
1952 | } | |
1953 | /* NOTREACHED */ | |
1954 | } | |
1955 | ||
984263bc | 1956 | /* Global vfs data structures for msdosfs */ |
66a1ddf5 MD |
1957 | struct vop_ops msdosfs_vnode_vops = { |
1958 | .vop_default = vop_defaultop, | |
1959 | .vop_access = msdosfs_access, | |
1960 | .vop_bmap = msdosfs_bmap, | |
1961 | .vop_old_lookup = msdosfs_lookup, | |
1962 | .vop_open = msdosfs_open, | |
1963 | .vop_close = msdosfs_close, | |
1964 | .vop_old_create = msdosfs_create, | |
1965 | .vop_fsync = msdosfs_fsync, | |
1966 | .vop_getattr = msdosfs_getattr, | |
1967 | .vop_inactive = msdosfs_inactive, | |
66a1ddf5 | 1968 | .vop_old_link = msdosfs_link, |
66a1ddf5 MD |
1969 | .vop_old_mkdir = msdosfs_mkdir, |
1970 | .vop_old_mknod = msdosfs_mknod, | |
1971 | .vop_pathconf = msdosfs_pathconf, | |
1972 | .vop_print = msdosfs_print, | |
1973 | .vop_read = msdosfs_read, | |
1974 | .vop_readdir = msdosfs_readdir, | |
1975 | .vop_reclaim = msdosfs_reclaim, | |
1976 | .vop_old_remove = msdosfs_remove, | |
1977 | .vop_old_rename = msdosfs_rename, | |
1978 | .vop_old_rmdir = msdosfs_rmdir, | |
1979 | .vop_setattr = msdosfs_setattr, | |
1980 | .vop_strategy = msdosfs_strategy, | |
1981 | .vop_old_symlink = msdosfs_symlink, | |
66a1ddf5 | 1982 | .vop_write = msdosfs_write, |
1787385d MD |
1983 | .vop_getpages = vop_stdgetpages, |
1984 | .vop_putpages = vop_stdputpages | |
984263bc | 1985 | }; |