1 /* $NetBSD: ext2fs_readwrite.c,v 1.74 2015/03/28 19:24:04 maxv Exp $ */
2
3 /*-
4 * Copyright (c) 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * @(#)ufs_readwrite.c 8.8 (Berkeley) 8/4/94
32 * Modified for ext2fs by Manuel Bouyer.
33 */
34
35 /*-
36 * Copyright (c) 1997 Manuel Bouyer.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
50 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
51 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
52 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
56 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57 *
58 * @(#)ufs_readwrite.c 8.8 (Berkeley) 8/4/94
59 * Modified for ext2fs by Manuel Bouyer.
60 */
61
62 #include <sys/cdefs.h>
63 __KERNEL_RCSID(0, "$NetBSD: ext2fs_readwrite.c,v 1.74 2015/03/28 19:24:04 maxv Exp $");
64
65 #include <sys/param.h>
66 #include <sys/systm.h>
67 #include <sys/resourcevar.h>
68 #include <sys/kernel.h>
69 #include <sys/file.h>
70 #include <sys/stat.h>
71 #include <sys/buf.h>
72 #include <sys/proc.h>
73 #include <sys/mount.h>
74 #include <sys/vnode.h>
75 #include <sys/signalvar.h>
76 #include <sys/kauth.h>
77
78 #include <ufs/ufs/inode.h>
79 #include <ufs/ufs/ufsmount.h>
80 #include <ufs/ufs/ufs_extern.h>
81 #include <ufs/ext2fs/ext2fs.h>
82 #include <ufs/ext2fs/ext2fs_extern.h>
83
84 static int ext2fs_post_read_update(struct vnode *, int, int);
85 static int ext2fs_post_write_update(struct vnode *, struct uio *, int,
86 kauth_cred_t, off_t, int, int, int);
87
88 /*
89 * Vnode op for reading.
90 */
91 /* ARGSUSED */
92 int
ext2fs_read(void * v)93 ext2fs_read(void *v)
94 {
95 struct vop_read_args /* {
96 struct vnode *a_vp;
97 struct uio *a_uio;
98 int a_ioflag;
99 kauth_cred_t a_cred;
100 } */ *ap = v;
101 struct vnode *vp;
102 struct inode *ip;
103 struct uio *uio;
104 struct ufsmount *ump;
105 vsize_t bytelen;
106 int advice;
107 int error;
108
109 vp = ap->a_vp;
110 ip = VTOI(vp);
111 ump = ip->i_ump;
112 uio = ap->a_uio;
113 error = 0;
114
115 KASSERT(uio->uio_rw == UIO_READ);
116 KASSERT(vp->v_type == VREG || vp->v_type == VDIR);
117
118 /* XXX Eliminate me by refusing directory reads from userland. */
119 if (vp->v_type == VDIR)
120 return ext2fs_bufrd(vp, uio, ap->a_ioflag, ap->a_cred);
121
122 if ((uint64_t)uio->uio_offset > ump->um_maxfilesize)
123 return (EFBIG);
124 if (uio->uio_resid == 0)
125 return (0);
126 if (uio->uio_offset >= ext2fs_size(ip))
127 goto out;
128
129 KASSERT(vp->v_type == VREG);
130 advice = IO_ADV_DECODE(ap->a_ioflag);
131 while (uio->uio_resid > 0) {
132 bytelen = MIN(ext2fs_size(ip) - uio->uio_offset,
133 uio->uio_resid);
134 if (bytelen == 0)
135 break;
136
137 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, advice,
138 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp));
139 if (error)
140 break;
141 }
142
143 out:
144 error = ext2fs_post_read_update(vp, ap->a_ioflag, error);
145 return (error);
146 }
147
148 /*
149 * UFS op for reading via the buffer cache
150 */
151 int
ext2fs_bufrd(struct vnode * vp,struct uio * uio,int ioflag,kauth_cred_t cred)152 ext2fs_bufrd(struct vnode *vp, struct uio *uio, int ioflag, kauth_cred_t cred)
153 {
154 struct inode *ip;
155 struct ufsmount *ump;
156 struct m_ext2fs *fs;
157 struct buf *bp;
158 off_t bytesinfile;
159 daddr_t lbn, nextlbn;
160 long size, xfersize, blkoffset;
161 int error;
162
163 KASSERT(uio->uio_rw == UIO_READ);
164 KASSERT(VOP_ISLOCKED(vp));
165 KASSERT(vp->v_type == VDIR || vp->v_type == VLNK);
166
167 ip = VTOI(vp);
168 ump = ip->i_ump;
169 fs = ip->i_e2fs;
170 error = 0;
171
172 KASSERT(vp->v_type != VLNK ||
173 ext2fs_size(ip) >= ump->um_maxsymlinklen);
174 KASSERT(vp->v_type != VLNK || ump->um_maxsymlinklen != 0 ||
175 ext2fs_nblock(ip) != 0);
176
177 if (uio->uio_offset > ump->um_maxfilesize)
178 return EFBIG;
179 if (uio->uio_resid == 0)
180 return 0;
181 if (uio->uio_offset >= ext2fs_size(ip))
182 goto out;
183
184 for (error = 0, bp = NULL; uio->uio_resid > 0; bp = NULL) {
185 bytesinfile = ext2fs_size(ip) - uio->uio_offset;
186 if (bytesinfile <= 0)
187 break;
188 lbn = ext2_lblkno(fs, uio->uio_offset);
189 nextlbn = lbn + 1;
190 size = fs->e2fs_bsize;
191 blkoffset = ext2_blkoff(fs, uio->uio_offset);
192 xfersize = fs->e2fs_bsize - blkoffset;
193 if (uio->uio_resid < xfersize)
194 xfersize = uio->uio_resid;
195 if (bytesinfile < xfersize)
196 xfersize = bytesinfile;
197
198 if (ext2_lblktosize(fs, nextlbn) >= ext2fs_size(ip))
199 error = bread(vp, lbn, size, 0, &bp);
200 else {
201 int nextsize = fs->e2fs_bsize;
202 error = breadn(vp, lbn,
203 size, &nextlbn, &nextsize, 1, 0, &bp);
204 }
205 if (error)
206 break;
207
208 /*
209 * We should only get non-zero b_resid when an I/O error
210 * has occurred, which should cause us to break above.
211 * However, if the short read did not cause an error,
212 * then we want to ensure that we do not uiomove bad
213 * or uninitialized data.
214 */
215 size -= bp->b_resid;
216 if (size < xfersize) {
217 if (size == 0)
218 break;
219 xfersize = size;
220 }
221 error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
222 if (error)
223 break;
224 brelse(bp, 0);
225 }
226 if (bp != NULL)
227 brelse(bp, 0);
228
229 out:
230 error = ext2fs_post_read_update(vp, ioflag, error);
231 return (error);
232 }
233
234 static int
ext2fs_post_read_update(struct vnode * vp,int ioflag,int oerror)235 ext2fs_post_read_update(struct vnode *vp, int ioflag, int oerror)
236 {
237 struct inode *ip = VTOI(vp);
238 int error = oerror;
239
240 if (!(vp->v_mount->mnt_flag & MNT_NOATIME)) {
241 ip->i_flag |= IN_ACCESS;
242 if ((ioflag & IO_SYNC) == IO_SYNC)
243 error = ext2fs_update(vp, NULL, NULL, UPDATE_WAIT);
244 }
245
246 /* Read error overrides any inode update error. */
247 if (oerror)
248 error = oerror;
249 return error;
250 }
251
252 /*
253 * Vnode op for writing.
254 */
255 int
ext2fs_write(void * v)256 ext2fs_write(void *v)
257 {
258 struct vop_write_args /* {
259 struct vnode *a_vp;
260 struct uio *a_uio;
261 int a_ioflag;
262 kauth_cred_t a_cred;
263 } */ *ap = v;
264 struct vnode *vp;
265 struct uio *uio;
266 struct inode *ip;
267 struct m_ext2fs *fs;
268 struct ufsmount *ump;
269 off_t osize;
270 int blkoffset, error, ioflag, resid;
271 vsize_t bytelen;
272 off_t oldoff = 0; /* XXX */
273 bool async;
274 int extended = 0;
275 int advice;
276
277 ioflag = ap->a_ioflag;
278 advice = IO_ADV_DECODE(ioflag);
279 uio = ap->a_uio;
280 vp = ap->a_vp;
281 ip = VTOI(vp);
282 ump = ip->i_ump;
283 error = 0;
284
285 KASSERT(uio->uio_rw == UIO_WRITE);
286 KASSERT(vp->v_type == VREG);
287
288 if (ioflag & IO_APPEND)
289 uio->uio_offset = ext2fs_size(ip);
290 if ((ip->i_e2fs_flags & EXT2_APPEND) &&
291 uio->uio_offset != ext2fs_size(ip))
292 return (EPERM);
293
294 fs = ip->i_e2fs;
295 if (uio->uio_offset < 0 ||
296 (uint64_t)uio->uio_offset + uio->uio_resid > ump->um_maxfilesize)
297 return (EFBIG);
298 if (uio->uio_resid == 0)
299 return (0);
300
301 async = vp->v_mount->mnt_flag & MNT_ASYNC;
302 resid = uio->uio_resid;
303 osize = ext2fs_size(ip);
304
305 KASSERT(vp->v_type == VREG);
306 while (uio->uio_resid > 0) {
307 oldoff = uio->uio_offset;
308 blkoffset = ext2_blkoff(fs, uio->uio_offset);
309 bytelen = MIN(fs->e2fs_bsize - blkoffset, uio->uio_resid);
310
311 if (vp->v_size < oldoff + bytelen) {
312 uvm_vnp_setwritesize(vp, oldoff + bytelen);
313 }
314 error = ufs_balloc_range(vp, uio->uio_offset, bytelen,
315 ap->a_cred, 0);
316 if (error)
317 break;
318 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, advice,
319 UBC_WRITE | UBC_UNMAP_FLAG(vp));
320 if (error)
321 break;
322
323 /*
324 * update UVM's notion of the size now that we've
325 * copied the data into the vnode's pages.
326 */
327
328 if (vp->v_size < uio->uio_offset) {
329 uvm_vnp_setsize(vp, uio->uio_offset);
330 extended = 1;
331 }
332
333 /*
334 * flush what we just wrote if necessary.
335 * XXXUBC simplistic async flushing.
336 */
337
338 if (!async && oldoff >> 16 != uio->uio_offset >> 16) {
339 mutex_enter(vp->v_interlock);
340 error = VOP_PUTPAGES(vp, (oldoff >> 16) << 16,
341 (uio->uio_offset >> 16) << 16,
342 PGO_CLEANIT | PGO_LAZY);
343 }
344 }
345 if (error == 0 && ioflag & IO_SYNC) {
346 mutex_enter(vp->v_interlock);
347 error = VOP_PUTPAGES(vp, trunc_page(oldoff),
348 round_page(ext2_blkroundup(fs, uio->uio_offset)),
349 PGO_CLEANIT | PGO_SYNCIO);
350 }
351
352 error = ext2fs_post_write_update(vp, uio, ioflag, ap->a_cred, osize,
353 resid, extended, error);
354 return (error);
355 }
356
357 /*
358 * UFS op for writing via the buffer cache
359 */
360 int
ext2fs_bufwr(struct vnode * vp,struct uio * uio,int ioflag,kauth_cred_t cred)361 ext2fs_bufwr(struct vnode *vp, struct uio *uio, int ioflag, kauth_cred_t cred)
362 {
363 struct inode *ip;
364 struct ufsmount *ump;
365 struct m_ext2fs *fs;
366 struct buf *bp;
367 int flags;
368 off_t osize;
369 daddr_t lbn;
370 int resid, blkoffset, xfersize;
371 int extended = 0;
372 int error;
373
374 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE);
375 KASSERT(vp->v_type == VDIR || vp->v_type == VLNK);
376 KASSERT(vp->v_type != VDIR || ISSET(ioflag, IO_SYNC));
377 KASSERT(uio->uio_rw == UIO_WRITE);
378
379 ip = VTOI(vp);
380 ump = ip->i_ump;
381 fs = ip->i_e2fs;
382 error = 0;
383
384 if (uio->uio_offset < 0 ||
385 uio->uio_resid > ump->um_maxfilesize ||
386 uio->uio_offset > (ump->um_maxfilesize - uio->uio_resid))
387 return EFBIG;
388 if (uio->uio_resid == 0)
389 return 0;
390
391 flags = ioflag & IO_SYNC ? B_SYNC : 0;
392 resid = uio->uio_resid;
393 osize = ext2fs_size(ip);
394
395 for (error = 0; uio->uio_resid > 0;) {
396 lbn = ext2_lblkno(fs, uio->uio_offset);
397 blkoffset = ext2_blkoff(fs, uio->uio_offset);
398 xfersize = MIN(fs->e2fs_bsize - blkoffset, uio->uio_resid);
399 if (xfersize < fs->e2fs_bsize)
400 flags |= B_CLRBUF;
401 else
402 flags &= ~B_CLRBUF;
403 error = ext2fs_balloc(ip, lbn, blkoffset + xfersize, cred, &bp,
404 flags);
405 if (error)
406 break;
407 if (ext2fs_size(ip) < uio->uio_offset + xfersize) {
408 error = ext2fs_setsize(ip, uio->uio_offset + xfersize);
409 if (error)
410 break;
411 }
412 error = uiomove((char *)bp->b_data + blkoffset, xfersize, uio);
413
414 /*
415 * update UVM's notion of the size now that we've
416 * copied the data into the vnode's pages.
417 */
418
419 if (vp->v_size < uio->uio_offset) {
420 uvm_vnp_setsize(vp, uio->uio_offset);
421 extended = 1;
422 }
423
424 if (ioflag & IO_SYNC)
425 (void)bwrite(bp);
426 else if (xfersize + blkoffset == fs->e2fs_bsize)
427 bawrite(bp);
428 else
429 bdwrite(bp);
430 if (error || xfersize == 0)
431 break;
432 }
433
434 error = ext2fs_post_write_update(vp, uio, ioflag, cred, osize, resid,
435 extended, error);
436 return (error);
437 }
438
439 static int
ext2fs_post_write_update(struct vnode * vp,struct uio * uio,int ioflag,kauth_cred_t cred,off_t osize,int resid,int extended,int oerror)440 ext2fs_post_write_update(struct vnode *vp, struct uio *uio, int ioflag,
441 kauth_cred_t cred, off_t osize, int resid, int extended, int oerror)
442 {
443 struct inode *ip = VTOI(vp);
444 int error = oerror;
445
446 /* Trigger ctime and mtime updates, and atime if MNT_RELATIME. */
447 ip->i_flag |= IN_CHANGE | IN_UPDATE;
448 if (vp->v_mount->mnt_flag & MNT_RELATIME)
449 ip->i_flag |= IN_ACCESS;
450
451 /*
452 * If we successfully wrote any data and we are not the superuser,
453 * we clear the setuid and setgid bits as a precaution against
454 * tampering.
455 */
456 if (resid > uio->uio_resid && cred) {
457 if (ip->i_e2fs_mode & ISUID) {
458 if (kauth_authorize_vnode(cred,
459 KAUTH_VNODE_RETAIN_SUID, vp, NULL, EPERM) != 0)
460 ip->i_e2fs_mode &= ISUID;
461 }
462
463 if (ip->i_e2fs_mode & ISGID) {
464 if (kauth_authorize_vnode(cred,
465 KAUTH_VNODE_RETAIN_SGID, vp, NULL, EPERM) != 0)
466 ip->i_e2fs_mode &= ~ISGID;
467 }
468 }
469
470 /* If we successfully wrote anything, notify kevent listeners. */
471 if (resid > uio->uio_resid)
472 VN_KNOTE(vp, NOTE_WRITE | (extended ? NOTE_EXTEND : 0));
473
474 /*
475 * Update the size on disk: truncate back to original size on
476 * error, or reflect the new size on success.
477 */
478 if (error) {
479 (void) ext2fs_truncate(vp, osize, ioflag & IO_SYNC, cred);
480 uio->uio_offset -= resid - uio->uio_resid;
481 uio->uio_resid = resid;
482 } else if (resid > uio->uio_resid && (ioflag & IO_SYNC) == IO_SYNC)
483 error = ext2fs_update(vp, NULL, NULL, UPDATE_WAIT);
484
485 /* Make sure the vnode uvm size matches the inode file size. */
486 KASSERT(vp->v_size == ext2fs_size(ip));
487
488 /* Write error overrides any inode update error. */
489 if (oerror)
490 error = oerror;
491 return error;
492 }
493