xref: /illumos-gate/usr/src/uts/common/fs/udfs/udf_vnops.c (revision 06042525)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*
27  * Copyright 2015, Joyent, Inc.
28  */
29 
30 #include <sys/types.h>
31 #include <sys/t_lock.h>
32 #include <sys/param.h>
33 #include <sys/time.h>
34 #include <sys/systm.h>
35 #include <sys/sysmacros.h>
36 #include <sys/resource.h>
37 #include <sys/signal.h>
38 #include <sys/cred.h>
39 #include <sys/user.h>
40 #include <sys/buf.h>
41 #include <sys/vfs.h>
42 #include <sys/vfs_opreg.h>
43 #include <sys/stat.h>
44 #include <sys/vnode.h>
45 #include <sys/mode.h>
46 #include <sys/proc.h>
47 #include <sys/disp.h>
48 #include <sys/file.h>
49 #include <sys/fcntl.h>
50 #include <sys/flock.h>
51 #include <sys/kmem.h>
52 #include <sys/uio.h>
53 #include <sys/dnlc.h>
54 #include <sys/conf.h>
55 #include <sys/errno.h>
56 #include <sys/mman.h>
57 #include <sys/fbuf.h>
58 #include <sys/pathname.h>
59 #include <sys/debug.h>
60 #include <sys/vmsystm.h>
61 #include <sys/cmn_err.h>
62 #include <sys/dirent.h>
63 #include <sys/errno.h>
64 #include <sys/modctl.h>
65 #include <sys/statvfs.h>
66 #include <sys/mount.h>
67 #include <sys/sunddi.h>
68 #include <sys/bootconf.h>
69 #include <sys/policy.h>
70 
71 #include <vm/hat.h>
72 #include <vm/page.h>
73 #include <vm/pvn.h>
74 #include <vm/as.h>
75 #include <vm/seg.h>
76 #include <vm/seg_map.h>
77 #include <vm/seg_kmem.h>
78 #include <vm/seg_vn.h>
79 #include <vm/rm.h>
80 #include <vm/page.h>
81 #include <sys/swap.h>
82 
83 #include <fs/fs_subr.h>
84 
85 #include <sys/fs/udf_volume.h>
86 #include <sys/fs/udf_inode.h>
87 
88 static int32_t udf_open(struct vnode **,
89 	int32_t, struct cred *, caller_context_t *);
90 static int32_t udf_close(struct vnode *,
91 	int32_t, int32_t, offset_t, struct cred *, caller_context_t *);
92 static int32_t udf_read(struct vnode *,
93 	struct uio *, int32_t, struct cred *, caller_context_t *);
94 static int32_t udf_write(struct vnode *,
95 	struct uio *, int32_t, struct cred *, caller_context_t *);
96 static int32_t udf_ioctl(struct vnode *,
97 	int32_t, intptr_t, int32_t, struct cred *, int32_t *,
98 	caller_context_t *);
99 static int32_t udf_getattr(struct vnode *,
100 	struct vattr *, int32_t, struct cred *, caller_context_t *);
101 static int32_t udf_setattr(struct vnode *,
102 	struct vattr *, int32_t, struct cred *, caller_context_t *);
103 static int32_t udf_access(struct vnode *,
104 	int32_t, int32_t, struct cred *, caller_context_t *);
105 static int32_t udf_lookup(struct vnode *,
106 	char *, struct vnode **, struct pathname *,
107 	int32_t, struct vnode *, struct cred *,
108 	caller_context_t *, int *, pathname_t *);
109 static int32_t udf_create(struct vnode *,
110 	char *, struct vattr *, enum vcexcl,
111 	int32_t, struct vnode **, struct cred *, int32_t,
112 	caller_context_t *, vsecattr_t *);
113 static int32_t udf_remove(struct vnode *,
114 	char *, struct cred *, caller_context_t *, int);
115 static int32_t udf_link(struct vnode *,
116 	struct vnode *, char *, struct cred *, caller_context_t *, int);
117 static int32_t udf_rename(struct vnode *,
118 	char *, struct vnode *, char *, struct cred *, caller_context_t *, int);
119 static int32_t udf_mkdir(struct vnode *,
120 	char *, struct vattr *, struct vnode **, struct cred *,
121 	caller_context_t *, int, vsecattr_t *);
122 static int32_t udf_rmdir(struct vnode *,
123 	char *, struct vnode *, struct cred *, caller_context_t *, int);
124 static int32_t udf_readdir(struct vnode *,
125 	struct uio *, struct cred *, int32_t *, caller_context_t *, int);
126 static int32_t udf_symlink(struct vnode *,
127 	char *, struct vattr *, char *, struct cred *, caller_context_t *, int);
128 static int32_t udf_readlink(struct vnode *,
129 	struct uio *, struct cred *, caller_context_t *);
130 static int32_t udf_fsync(struct vnode *,
131 	int32_t, struct cred *, caller_context_t *);
132 static void udf_inactive(struct vnode *,
133 	struct cred *, caller_context_t *);
134 static int32_t udf_fid(struct vnode *, struct fid *, caller_context_t *);
135 static int udf_rwlock(struct vnode *, int32_t, caller_context_t *);
136 static void udf_rwunlock(struct vnode *, int32_t, caller_context_t *);
137 static int32_t udf_seek(struct vnode *, offset_t, offset_t *,
138 	caller_context_t *);
139 static int32_t udf_frlock(struct vnode *, int32_t,
140 	struct flock64 *, int32_t, offset_t, struct flk_callback *, cred_t *,
141 	caller_context_t *);
142 static int32_t udf_space(struct vnode *, int32_t,
143 	struct flock64 *, int32_t, offset_t, cred_t *, caller_context_t *);
144 static int32_t udf_getpage(struct vnode *, offset_t,
145 	size_t, uint32_t *, struct page **, size_t,
146 	struct seg *, caddr_t, enum seg_rw, struct cred *, caller_context_t *);
147 static int32_t udf_putpage(struct vnode *, offset_t,
148 	size_t, int32_t, struct cred *, caller_context_t *);
149 static int32_t udf_map(struct vnode *, offset_t, struct as *,
150 	caddr_t *, size_t, uint8_t, uint8_t, uint32_t, struct cred *,
151 	caller_context_t *);
152 static int32_t udf_addmap(struct vnode *, offset_t, struct as *,
153 	caddr_t, size_t, uint8_t, uint8_t, uint32_t, struct cred *,
154 	caller_context_t *);
155 static int32_t udf_delmap(struct vnode *, offset_t, struct as *,
156 	caddr_t, size_t, uint32_t, uint32_t, uint32_t, struct cred *,
157 	caller_context_t *);
158 static int32_t udf_l_pathconf(struct vnode *, int32_t,
159 	ulong_t *, struct cred *, caller_context_t *);
160 static int32_t udf_pageio(struct vnode *, struct page *,
161 	u_offset_t, size_t, int32_t, struct cred *, caller_context_t *);
162 
163 int32_t ud_getpage_miss(struct vnode *, u_offset_t,
164 	size_t, struct seg *, caddr_t, page_t *pl[],
165 	size_t, enum seg_rw, int32_t);
166 void ud_getpage_ra(struct vnode *, u_offset_t, struct seg *, caddr_t);
167 int32_t ud_putpages(struct vnode *, offset_t, size_t, int32_t, struct cred *);
168 int32_t ud_page_fill(struct ud_inode *, page_t *,
169 	u_offset_t, uint32_t, u_offset_t *);
170 int32_t ud_iodone(struct buf *);
171 int32_t ud_rdip(struct ud_inode *, struct uio *, int32_t, cred_t *);
172 int32_t ud_wrip(struct ud_inode *, struct uio *, int32_t, cred_t *);
173 int32_t ud_multi_strat(struct ud_inode *, page_t *, struct buf *, u_offset_t);
174 int32_t ud_slave_done(struct buf *);
175 
176 /*
177  * Structures to control multiple IO operations to get or put pages
178  * that are backed by discontiguous blocks. The master struct is
179  * a dummy that holds the original bp from pageio_setup. The
180  * slave struct holds the working bp's to do the actual IO. Once
181  * all the slave IOs complete. The master is processed as if a single
182  * IO op has completed.
183  */
184 uint32_t master_index = 0;
185 typedef struct mio_master {
186 	kmutex_t	mm_mutex;	/* protect the fields below */
187 	int32_t		mm_size;
188 	buf_t		*mm_bp;		/* original bp */
189 	int32_t		mm_resid;	/* bytes remaining to transfer */
190 	int32_t		mm_error;	/* accumulated error from slaves */
191 	int32_t		mm_index;	/* XXX debugging */
192 } mio_master_t;
193 
194 typedef struct mio_slave {
195 	buf_t		ms_buf;		/* working buffer for this IO chunk */
196 	mio_master_t	*ms_ptr;	/* pointer to master */
197 } mio_slave_t;
198 
199 struct vnodeops *udf_vnodeops;
200 
201 const fs_operation_def_t udf_vnodeops_template[] = {
202 	VOPNAME_OPEN,		{ .vop_open = udf_open },
203 	VOPNAME_CLOSE,		{ .vop_close = udf_close },
204 	VOPNAME_READ,		{ .vop_read = udf_read },
205 	VOPNAME_WRITE,		{ .vop_write = udf_write },
206 	VOPNAME_IOCTL,		{ .vop_ioctl = udf_ioctl },
207 	VOPNAME_GETATTR,	{ .vop_getattr = udf_getattr },
208 	VOPNAME_SETATTR,	{ .vop_setattr = udf_setattr },
209 	VOPNAME_ACCESS,		{ .vop_access = udf_access },
210 	VOPNAME_LOOKUP,		{ .vop_lookup = udf_lookup },
211 	VOPNAME_CREATE,		{ .vop_create = udf_create },
212 	VOPNAME_REMOVE,		{ .vop_remove = udf_remove },
213 	VOPNAME_LINK,		{ .vop_link = udf_link },
214 	VOPNAME_RENAME,		{ .vop_rename = udf_rename },
215 	VOPNAME_MKDIR,		{ .vop_mkdir = udf_mkdir },
216 	VOPNAME_RMDIR,		{ .vop_rmdir = udf_rmdir },
217 	VOPNAME_READDIR,	{ .vop_readdir = udf_readdir },
218 	VOPNAME_SYMLINK,	{ .vop_symlink = udf_symlink },
219 	VOPNAME_READLINK,	{ .vop_readlink = udf_readlink },
220 	VOPNAME_FSYNC,		{ .vop_fsync = udf_fsync },
221 	VOPNAME_INACTIVE,	{ .vop_inactive = udf_inactive },
222 	VOPNAME_FID,		{ .vop_fid = udf_fid },
223 	VOPNAME_RWLOCK,		{ .vop_rwlock = udf_rwlock },
224 	VOPNAME_RWUNLOCK,	{ .vop_rwunlock = udf_rwunlock },
225 	VOPNAME_SEEK,		{ .vop_seek = udf_seek },
226 	VOPNAME_FRLOCK,		{ .vop_frlock = udf_frlock },
227 	VOPNAME_SPACE,		{ .vop_space = udf_space },
228 	VOPNAME_GETPAGE,	{ .vop_getpage = udf_getpage },
229 	VOPNAME_PUTPAGE,	{ .vop_putpage = udf_putpage },
230 	VOPNAME_MAP,		{ .vop_map = udf_map },
231 	VOPNAME_ADDMAP,		{ .vop_addmap = udf_addmap },
232 	VOPNAME_DELMAP,		{ .vop_delmap = udf_delmap },
233 	VOPNAME_PATHCONF,	{ .vop_pathconf = udf_l_pathconf },
234 	VOPNAME_PAGEIO,		{ .vop_pageio = udf_pageio },
235 	VOPNAME_VNEVENT,	{ .vop_vnevent = fs_vnevent_support },
236 	NULL,			NULL
237 };
238 
239 /* ARGSUSED */
240 static int32_t
udf_open(struct vnode ** vpp,int32_t flag,struct cred * cr,caller_context_t * ct)241 udf_open(
242 	struct vnode **vpp,
243 	int32_t flag,
244 	struct cred *cr,
245 	caller_context_t *ct)
246 {
247 	ud_printf("udf_open\n");
248 
249 	return (0);
250 }
251 
252 /* ARGSUSED */
253 static int32_t
udf_close(struct vnode * vp,int32_t flag,int32_t count,offset_t offset,struct cred * cr,caller_context_t * ct)254 udf_close(
255 	struct vnode *vp,
256 	int32_t flag,
257 	int32_t count,
258 	offset_t offset,
259 	struct cred *cr,
260 	caller_context_t *ct)
261 {
262 	struct ud_inode *ip = VTOI(vp);
263 
264 	ud_printf("udf_close\n");
265 
266 	ITIMES(ip);
267 
268 	cleanlocks(vp, ttoproc(curthread)->p_pid, 0);
269 	cleanshares(vp, ttoproc(curthread)->p_pid);
270 
271 	/*
272 	 * Push partially filled cluster at last close.
273 	 * ``last close'' is approximated because the dnlc
274 	 * may have a hold on the vnode.
275 	 */
276 	if (vp->v_count <= 2 && vp->v_type != VBAD) {
277 		struct ud_inode *ip = VTOI(vp);
278 		if (ip->i_delaylen) {
279 			(void) ud_putpages(vp, ip->i_delayoff, ip->i_delaylen,
280 			    B_ASYNC | B_FREE, cr);
281 			ip->i_delaylen = 0;
282 		}
283 	}
284 
285 	return (0);
286 }
287 
288 /* ARGSUSED */
289 static int32_t
udf_read(struct vnode * vp,struct uio * uiop,int32_t ioflag,struct cred * cr,caller_context_t * ct)290 udf_read(
291 	struct vnode *vp,
292 	struct uio *uiop,
293 	int32_t ioflag,
294 	struct cred *cr,
295 	caller_context_t *ct)
296 {
297 	struct ud_inode *ip = VTOI(vp);
298 	int32_t error;
299 
300 	ud_printf("udf_read\n");
301 
302 #ifdef	__lock_lint
303 	rw_enter(&ip->i_rwlock, RW_READER);
304 #endif
305 
306 	ASSERT(RW_READ_HELD(&ip->i_rwlock));
307 
308 	if (MANDLOCK(vp, ip->i_char)) {
309 		/*
310 		 * udf_getattr ends up being called by chklock
311 		 */
312 		error = chklock(vp, FREAD, uiop->uio_loffset,
313 		    uiop->uio_resid, uiop->uio_fmode, ct);
314 		if (error) {
315 			goto end;
316 		}
317 	}
318 
319 	rw_enter(&ip->i_contents, RW_READER);
320 	error = ud_rdip(ip, uiop, ioflag, cr);
321 	rw_exit(&ip->i_contents);
322 
323 end:
324 #ifdef	__lock_lint
325 	rw_exit(&ip->i_rwlock);
326 #endif
327 
328 	return (error);
329 }
330 
331 
332 int32_t ud_WRITES = 1;
333 int32_t ud_HW = 96 * 1024;
334 int32_t ud_LW = 64 * 1024;
335 int32_t ud_throttles = 0;
336 
337 /* ARGSUSED */
338 static int32_t
udf_write(struct vnode * vp,struct uio * uiop,int32_t ioflag,struct cred * cr,caller_context_t * ct)339 udf_write(
340 	struct vnode *vp,
341 	struct uio *uiop,
342 	int32_t ioflag,
343 	struct cred *cr,
344 	caller_context_t *ct)
345 {
346 	struct ud_inode *ip = VTOI(vp);
347 	int32_t error = 0;
348 
349 	ud_printf("udf_write\n");
350 
351 #ifdef	__lock_lint
352 	rw_enter(&ip->i_rwlock, RW_WRITER);
353 #endif
354 
355 	ASSERT(RW_WRITE_HELD(&ip->i_rwlock));
356 
357 	if (MANDLOCK(vp, ip->i_char)) {
358 		/*
359 		 * ud_getattr ends up being called by chklock
360 		 */
361 		error = chklock(vp, FWRITE, uiop->uio_loffset,
362 		    uiop->uio_resid, uiop->uio_fmode, ct);
363 		if (error) {
364 			goto end;
365 		}
366 	}
367 	/*
368 	 * Throttle writes.
369 	 */
370 	mutex_enter(&ip->i_tlock);
371 	if (ud_WRITES && (ip->i_writes > ud_HW)) {
372 		while (ip->i_writes > ud_HW) {
373 			ud_throttles++;
374 			cv_wait(&ip->i_wrcv, &ip->i_tlock);
375 		}
376 	}
377 	mutex_exit(&ip->i_tlock);
378 
379 	/*
380 	 * Write to the file
381 	 */
382 	rw_enter(&ip->i_contents, RW_WRITER);
383 	if ((ioflag & FAPPEND) != 0 && (ip->i_type == VREG)) {
384 		/*
385 		 * In append mode start at end of file.
386 		 */
387 		uiop->uio_loffset = ip->i_size;
388 	}
389 	error = ud_wrip(ip, uiop, ioflag, cr);
390 	rw_exit(&ip->i_contents);
391 
392 end:
393 #ifdef	__lock_lint
394 	rw_exit(&ip->i_rwlock);
395 #endif
396 
397 	return (error);
398 }
399 
400 /* ARGSUSED */
401 static int32_t
udf_ioctl(struct vnode * vp,int32_t cmd,intptr_t arg,int32_t flag,struct cred * cr,int32_t * rvalp,caller_context_t * ct)402 udf_ioctl(
403 	struct vnode *vp,
404 	int32_t cmd,
405 	intptr_t arg,
406 	int32_t flag,
407 	struct cred *cr,
408 	int32_t *rvalp,
409 	caller_context_t *ct)
410 {
411 	return (ENOTTY);
412 }
413 
414 /* ARGSUSED */
415 static int32_t
udf_getattr(struct vnode * vp,struct vattr * vap,int32_t flags,struct cred * cr,caller_context_t * ct)416 udf_getattr(
417 	struct vnode *vp,
418 	struct vattr *vap,
419 	int32_t flags,
420 	struct cred *cr,
421 	caller_context_t *ct)
422 {
423 	struct ud_inode *ip = VTOI(vp);
424 
425 	ud_printf("udf_getattr\n");
426 
427 	if (vap->va_mask == AT_SIZE) {
428 		/*
429 		 * for performance, if only the size is requested don't bother
430 		 * with anything else.
431 		 */
432 		vap->va_size = ip->i_size;
433 		return (0);
434 	}
435 
436 	rw_enter(&ip->i_contents, RW_READER);
437 
438 	vap->va_type = vp->v_type;
439 	vap->va_mode = UD2VA_PERM(ip->i_perm) | ip->i_char;
440 
441 	vap->va_uid = ip->i_uid;
442 	vap->va_gid = ip->i_gid;
443 	vap->va_fsid = ip->i_dev;
444 	vap->va_nodeid = ip->i_icb_lbano;
445 	vap->va_nlink = ip->i_nlink;
446 	vap->va_size = ip->i_size;
447 	vap->va_seq = ip->i_seq;
448 	if (vp->v_type == VCHR || vp->v_type == VBLK) {
449 		vap->va_rdev = ip->i_rdev;
450 	} else {
451 		vap->va_rdev = 0;
452 	}
453 
454 	mutex_enter(&ip->i_tlock);
455 	ITIMES_NOLOCK(ip);	/* mark correct time in inode */
456 	vap->va_atime.tv_sec = (time_t)ip->i_atime.tv_sec;
457 	vap->va_atime.tv_nsec = ip->i_atime.tv_nsec;
458 	vap->va_mtime.tv_sec = (time_t)ip->i_mtime.tv_sec;
459 	vap->va_mtime.tv_nsec = ip->i_mtime.tv_nsec;
460 	vap->va_ctime.tv_sec = (time_t)ip->i_ctime.tv_sec;
461 	vap->va_ctime.tv_nsec = ip->i_ctime.tv_nsec;
462 	mutex_exit(&ip->i_tlock);
463 
464 	switch (ip->i_type) {
465 		case VBLK:
466 			vap->va_blksize = MAXBSIZE;
467 			break;
468 		case VCHR:
469 			vap->va_blksize = MAXBSIZE;
470 			break;
471 		default:
472 			vap->va_blksize = ip->i_udf->udf_lbsize;
473 			break;
474 	}
475 	vap->va_nblocks = ip->i_lbr << ip->i_udf->udf_l2d_shift;
476 
477 	rw_exit(&ip->i_contents);
478 
479 	return (0);
480 }
481 
482 static int
ud_iaccess_vmode(void * ip,int mode,struct cred * cr)483 ud_iaccess_vmode(void *ip, int mode, struct cred *cr)
484 {
485 	return (ud_iaccess(ip, UD_UPERM2DPERM(mode), cr, 0));
486 }
487 
488 /*ARGSUSED4*/
489 static int32_t
udf_setattr(struct vnode * vp,struct vattr * vap,int32_t flags,struct cred * cr,caller_context_t * ct)490 udf_setattr(
491 	struct vnode *vp,
492 	struct vattr *vap,
493 	int32_t flags,
494 	struct cred *cr,
495 	caller_context_t *ct)
496 {
497 	int32_t error = 0;
498 	uint32_t mask = vap->va_mask;
499 	struct ud_inode *ip;
500 	timestruc_t now;
501 	struct vattr ovap;
502 
503 	ud_printf("udf_setattr\n");
504 
505 	ip = VTOI(vp);
506 
507 	/*
508 	 * not updates allowed to 4096 files
509 	 */
510 	if (ip->i_astrat == STRAT_TYPE4096) {
511 		return (EINVAL);
512 	}
513 
514 	/*
515 	 * Cannot set these attributes
516 	 */
517 	if (mask & AT_NOSET) {
518 		return (EINVAL);
519 	}
520 
521 	rw_enter(&ip->i_rwlock, RW_WRITER);
522 	rw_enter(&ip->i_contents, RW_WRITER);
523 
524 	ovap.va_uid = ip->i_uid;
525 	ovap.va_mode = UD2VA_PERM(ip->i_perm) | ip->i_char;
526 	error = secpolicy_vnode_setattr(cr, vp, vap, &ovap, flags,
527 	    ud_iaccess_vmode, ip);
528 	if (error)
529 		goto update_inode;
530 
531 	mask = vap->va_mask;
532 	/*
533 	 * Change file access modes.
534 	 */
535 	if (mask & AT_MODE) {
536 		ip->i_perm = VA2UD_PERM(vap->va_mode);
537 		ip->i_char = vap->va_mode & (VSUID | VSGID | VSVTX);
538 		mutex_enter(&ip->i_tlock);
539 		ip->i_flag |= ICHG;
540 		mutex_exit(&ip->i_tlock);
541 	}
542 	if (mask & (AT_UID|AT_GID)) {
543 		if (mask & AT_UID) {
544 			ip->i_uid = vap->va_uid;
545 		}
546 		if (mask & AT_GID) {
547 			ip->i_gid = vap->va_gid;
548 		}
549 		mutex_enter(&ip->i_tlock);
550 		ip->i_flag |= ICHG;
551 		mutex_exit(&ip->i_tlock);
552 	}
553 	/*
554 	 * Truncate file.  Must have write permission and not be a directory.
555 	 */
556 	if (mask & AT_SIZE) {
557 		if (vp->v_type == VDIR) {
558 			error = EISDIR;
559 			goto update_inode;
560 		}
561 		if (error = ud_iaccess(ip, IWRITE, cr, 0)) {
562 			goto update_inode;
563 		}
564 		if (vap->va_size > MAXOFFSET_T) {
565 			error = EFBIG;
566 			goto update_inode;
567 		}
568 		if (error = ud_itrunc(ip, vap->va_size, 0, cr)) {
569 			goto update_inode;
570 		}
571 
572 		if (vap->va_size == 0)
573 			vnevent_truncate(vp, ct);
574 	}
575 	/*
576 	 * Change file access or modified times.
577 	 */
578 	if (mask & (AT_ATIME|AT_MTIME)) {
579 		mutex_enter(&ip->i_tlock);
580 		if (mask & AT_ATIME) {
581 			ip->i_atime.tv_sec = vap->va_atime.tv_sec;
582 			ip->i_atime.tv_nsec = vap->va_atime.tv_nsec;
583 			ip->i_flag &= ~IACC;
584 		}
585 		if (mask & AT_MTIME) {
586 			ip->i_mtime.tv_sec = vap->va_mtime.tv_sec;
587 			ip->i_mtime.tv_nsec = vap->va_mtime.tv_nsec;
588 			gethrestime(&now);
589 			ip->i_ctime.tv_sec = now.tv_sec;
590 			ip->i_ctime.tv_nsec = now.tv_nsec;
591 			ip->i_flag &= ~(IUPD|ICHG);
592 			ip->i_flag |= IMODTIME;
593 		}
594 		ip->i_flag |= IMOD;
595 		mutex_exit(&ip->i_tlock);
596 	}
597 
598 update_inode:
599 	if (curthread->t_flag & T_DONTPEND) {
600 		ud_iupdat(ip, 1);
601 	} else {
602 		ITIMES_NOLOCK(ip);
603 	}
604 	rw_exit(&ip->i_contents);
605 	rw_exit(&ip->i_rwlock);
606 
607 	return (error);
608 }
609 
610 /* ARGSUSED */
611 static int32_t
udf_access(struct vnode * vp,int32_t mode,int32_t flags,struct cred * cr,caller_context_t * ct)612 udf_access(
613 	struct vnode *vp,
614 	int32_t mode,
615 	int32_t flags,
616 	struct cred *cr,
617 	caller_context_t *ct)
618 {
619 	struct ud_inode *ip = VTOI(vp);
620 
621 	ud_printf("udf_access\n");
622 
623 	if (ip->i_udf == NULL) {
624 		return (EIO);
625 	}
626 
627 	return (ud_iaccess(ip, UD_UPERM2DPERM(mode), cr, 1));
628 }
629 
630 int32_t udfs_stickyhack = 1;
631 
632 /* ARGSUSED */
633 static int32_t
udf_lookup(struct vnode * dvp,char * nm,struct vnode ** vpp,struct pathname * pnp,int32_t flags,struct vnode * rdir,struct cred * cr,caller_context_t * ct,int * direntflags,pathname_t * realpnp)634 udf_lookup(
635 	struct vnode *dvp,
636 	char *nm,
637 	struct vnode **vpp,
638 	struct pathname *pnp,
639 	int32_t flags,
640 	struct vnode *rdir,
641 	struct cred *cr,
642 	caller_context_t *ct,
643 	int *direntflags,
644 	pathname_t *realpnp)
645 {
646 	int32_t error;
647 	struct vnode *vp;
648 	struct ud_inode *ip, *xip;
649 
650 	ud_printf("udf_lookup\n");
651 	/*
652 	 * Null component name is a synonym for directory being searched.
653 	 */
654 	if (*nm == '\0') {
655 		VN_HOLD(dvp);
656 		*vpp = dvp;
657 		error = 0;
658 		goto out;
659 	}
660 
661 	/*
662 	 * Fast path: Check the directory name lookup cache.
663 	 */
664 	ip = VTOI(dvp);
665 	if (vp = dnlc_lookup(dvp, nm)) {
666 		/*
667 		 * Check accessibility of directory.
668 		 */
669 		if ((error = ud_iaccess(ip, IEXEC, cr, 1)) != 0) {
670 			VN_RELE(vp);
671 		}
672 		xip = VTOI(vp);
673 	} else {
674 		error = ud_dirlook(ip, nm, &xip, cr, 1);
675 		ITIMES(ip);
676 	}
677 
678 	if (error == 0) {
679 		ip = xip;
680 		*vpp = ITOV(ip);
681 		if ((ip->i_type != VDIR) &&
682 		    (ip->i_char & ISVTX) &&
683 		    ((ip->i_perm & IEXEC) == 0) &&
684 		    udfs_stickyhack) {
685 			mutex_enter(&(*vpp)->v_lock);
686 			(*vpp)->v_flag |= VISSWAP;
687 			mutex_exit(&(*vpp)->v_lock);
688 		}
689 		ITIMES(ip);
690 		/*
691 		 * If vnode is a device return special vnode instead.
692 		 */
693 		if (IS_DEVVP(*vpp)) {
694 			struct vnode *newvp;
695 			newvp = specvp(*vpp, (*vpp)->v_rdev,
696 			    (*vpp)->v_type, cr);
697 			VN_RELE(*vpp);
698 			if (newvp == NULL) {
699 				error = ENOSYS;
700 			} else {
701 				*vpp = newvp;
702 			}
703 		}
704 	}
705 out:
706 	return (error);
707 }
708 
709 /* ARGSUSED */
710 static int32_t
udf_create(struct vnode * dvp,char * name,struct vattr * vap,enum vcexcl excl,int32_t mode,struct vnode ** vpp,struct cred * cr,int32_t flag,caller_context_t * ct,vsecattr_t * vsecp)711 udf_create(
712 	struct vnode *dvp,
713 	char *name,
714 	struct vattr *vap,
715 	enum vcexcl excl,
716 	int32_t mode,
717 	struct vnode **vpp,
718 	struct cred *cr,
719 	int32_t flag,
720 	caller_context_t *ct,
721 	vsecattr_t *vsecp)
722 {
723 	int32_t error;
724 	struct ud_inode *ip = VTOI(dvp), *xip;
725 
726 	ud_printf("udf_create\n");
727 
728 	if ((vap->va_mode & VSVTX) && secpolicy_vnode_stky_modify(cr) != 0)
729 		vap->va_mode &= ~VSVTX;
730 
731 	if (*name == '\0') {
732 		/*
733 		 * Null component name refers to the directory itself.
734 		 */
735 		VN_HOLD(dvp);
736 		ITIMES(ip);
737 		error = EEXIST;
738 	} else {
739 		xip = NULL;
740 		rw_enter(&ip->i_rwlock, RW_WRITER);
741 		error = ud_direnter(ip, name, DE_CREATE,
742 		    (struct ud_inode *)0, (struct ud_inode *)0,
743 		    vap, &xip, cr, ct);
744 		rw_exit(&ip->i_rwlock);
745 		ITIMES(ip);
746 		ip = xip;
747 	}
748 #ifdef	__lock_lint
749 	rw_enter(&ip->i_contents, RW_WRITER);
750 #else
751 	if (ip != NULL) {
752 		rw_enter(&ip->i_contents, RW_WRITER);
753 	}
754 #endif
755 
756 	/*
757 	 * If the file already exists and this is a non-exclusive create,
758 	 * check permissions and allow access for non-directories.
759 	 * Read-only create of an existing directory is also allowed.
760 	 * We fail an exclusive create of anything which already exists.
761 	 */
762 	if (error == EEXIST) {
763 		if (excl == NONEXCL) {
764 			if ((ip->i_type == VDIR) && (mode & VWRITE)) {
765 				error = EISDIR;
766 			} else if (mode) {
767 				error = ud_iaccess(ip,
768 				    UD_UPERM2DPERM(mode), cr, 0);
769 			} else {
770 				error = 0;
771 			}
772 		}
773 		if (error) {
774 			rw_exit(&ip->i_contents);
775 			VN_RELE(ITOV(ip));
776 			goto out;
777 		} else if ((ip->i_type == VREG) &&
778 		    (vap->va_mask & AT_SIZE) && vap->va_size == 0) {
779 			/*
780 			 * Truncate regular files, if requested by caller.
781 			 * Grab i_rwlock to make sure no one else is
782 			 * currently writing to the file (we promised
783 			 * bmap we would do this).
784 			 * Must get the locks in the correct order.
785 			 */
786 			if (ip->i_size == 0) {
787 				ip->i_flag |= ICHG | IUPD;
788 			} else {
789 				rw_exit(&ip->i_contents);
790 				rw_enter(&ip->i_rwlock, RW_WRITER);
791 				rw_enter(&ip->i_contents, RW_WRITER);
792 				(void) ud_itrunc(ip, 0, 0, cr);
793 				rw_exit(&ip->i_rwlock);
794 			}
795 			vnevent_create(ITOV(ip), ct);
796 		}
797 	}
798 
799 	if (error == 0) {
800 		*vpp = ITOV(ip);
801 		ITIMES(ip);
802 	}
803 #ifdef	__lock_lint
804 	rw_exit(&ip->i_contents);
805 #else
806 	if (ip != NULL) {
807 		rw_exit(&ip->i_contents);
808 	}
809 #endif
810 	if (error) {
811 		goto out;
812 	}
813 
814 	/*
815 	 * If vnode is a device return special vnode instead.
816 	 */
817 	if (!error && IS_DEVVP(*vpp)) {
818 		struct vnode *newvp;
819 
820 		newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr);
821 		VN_RELE(*vpp);
822 		if (newvp == NULL) {
823 			error = ENOSYS;
824 			goto out;
825 		}
826 		*vpp = newvp;
827 	}
828 out:
829 	return (error);
830 }
831 
832 /* ARGSUSED */
833 static int32_t
udf_remove(struct vnode * vp,char * nm,struct cred * cr,caller_context_t * ct,int flags)834 udf_remove(
835 	struct vnode *vp,
836 	char *nm,
837 	struct cred *cr,
838 	caller_context_t *ct,
839 	int flags)
840 {
841 	int32_t error;
842 	struct ud_inode *ip = VTOI(vp);
843 
844 	ud_printf("udf_remove\n");
845 
846 	rw_enter(&ip->i_rwlock, RW_WRITER);
847 	error = ud_dirremove(ip, nm,
848 	    (struct ud_inode *)0, (struct vnode *)0, DR_REMOVE, cr, ct);
849 	rw_exit(&ip->i_rwlock);
850 	ITIMES(ip);
851 
852 	return (error);
853 }
854 
855 /* ARGSUSED */
856 static int32_t
udf_link(struct vnode * tdvp,struct vnode * svp,char * tnm,struct cred * cr,caller_context_t * ct,int flags)857 udf_link(
858 	struct vnode *tdvp,
859 	struct vnode *svp,
860 	char *tnm,
861 	struct cred *cr,
862 	caller_context_t *ct,
863 	int flags)
864 {
865 	int32_t error;
866 	struct vnode *realvp;
867 	struct ud_inode *sip;
868 	struct ud_inode *tdp;
869 
870 	ud_printf("udf_link\n");
871 	if (VOP_REALVP(svp, &realvp, ct) == 0) {
872 		svp = realvp;
873 	}
874 
875 	/*
876 	 * Do not allow links to directories
877 	 */
878 	if (svp->v_type == VDIR) {
879 		return (EPERM);
880 	}
881 
882 	sip = VTOI(svp);
883 
884 	if (sip->i_uid != crgetuid(cr) && secpolicy_basic_link(cr) != 0)
885 		return (EPERM);
886 
887 	tdp = VTOI(tdvp);
888 
889 	rw_enter(&tdp->i_rwlock, RW_WRITER);
890 	error = ud_direnter(tdp, tnm, DE_LINK, (struct ud_inode *)0,
891 	    sip, (struct vattr *)0, (struct ud_inode **)0, cr, ct);
892 	rw_exit(&tdp->i_rwlock);
893 	ITIMES(sip);
894 	ITIMES(tdp);
895 
896 	if (error == 0) {
897 		vnevent_link(svp, ct);
898 	}
899 
900 	return (error);
901 }
902 
903 /* ARGSUSED */
904 static int32_t
udf_rename(struct vnode * sdvp,char * snm,struct vnode * tdvp,char * tnm,struct cred * cr,caller_context_t * ct,int flags)905 udf_rename(
906 	struct vnode *sdvp,
907 	char *snm,
908 	struct vnode *tdvp,
909 	char *tnm,
910 	struct cred *cr,
911 	caller_context_t *ct,
912 	int flags)
913 {
914 	int32_t error = 0;
915 	struct udf_vfs *udf_vfsp;
916 	struct ud_inode *sip;		/* source inode */
917 	struct ud_inode *tip;		/* target inode */
918 	struct ud_inode *sdp, *tdp;	/* source and target parent inode */
919 	struct vnode *realvp;
920 
921 	ud_printf("udf_rename\n");
922 
923 	if (VOP_REALVP(tdvp, &realvp, ct) == 0) {
924 		tdvp = realvp;
925 	}
926 
927 	sdp = VTOI(sdvp);
928 	tdp = VTOI(tdvp);
929 
930 	udf_vfsp = sdp->i_udf;
931 
932 	mutex_enter(&udf_vfsp->udf_rename_lck);
933 	/*
934 	 * Look up inode of file we're supposed to rename.
935 	 */
936 	if (error = ud_dirlook(sdp, snm, &sip, cr, 0)) {
937 		mutex_exit(&udf_vfsp->udf_rename_lck);
938 		return (error);
939 	}
940 	/*
941 	 * be sure this is not a directory with another file system mounted
942 	 * over it.  If it is just give up the locks, and return with
943 	 * EBUSY
944 	 */
945 	if (vn_mountedvfs(ITOV(sip)) != NULL) {
946 		error = EBUSY;
947 		goto errout;
948 	}
949 	/*
950 	 * Make sure we can delete the source entry.  This requires
951 	 * write permission on the containing directory.  If that
952 	 * directory is "sticky" it further requires (except for
953 	 * privileged users) that the user own the directory or the
954 	 * source entry, or else have permission to write the source
955 	 * entry.
956 	 */
957 	rw_enter(&sdp->i_contents, RW_READER);
958 	rw_enter(&sip->i_contents, RW_READER);
959 	if ((error = ud_iaccess(sdp, IWRITE, cr, 0)) != 0 ||
960 	    (error = ud_sticky_remove_access(sdp, sip, cr)) != 0) {
961 		rw_exit(&sip->i_contents);
962 		rw_exit(&sdp->i_contents);
963 		ITIMES(sip);
964 		goto errout;
965 	}
966 
967 	/*
968 	 * Check for renaming '.' or '..' or alias of '.'
969 	 */
970 	if ((strcmp(snm, ".") == 0) ||
971 	    (strcmp(snm, "..") == 0) ||
972 	    (sdp == sip)) {
973 		error = EINVAL;
974 		rw_exit(&sip->i_contents);
975 		rw_exit(&sdp->i_contents);
976 		goto errout;
977 	}
978 
979 	rw_exit(&sip->i_contents);
980 	rw_exit(&sdp->i_contents);
981 
982 	if (ud_dirlook(tdp, tnm, &tip, cr, 0) == 0) {
983 		vnevent_pre_rename_dest(ITOV(tip), tdvp, tnm, ct);
984 		VN_RELE(ITOV(tip));
985 	}
986 
987 	/* Notify the target dir. if not the same as the source dir. */
988 	if (sdvp != tdvp)
989 		vnevent_pre_rename_dest_dir(tdvp, ITOV(sip), tnm, ct);
990 
991 	vnevent_pre_rename_src(ITOV(sip), sdvp, snm, ct);
992 
993 	/*
994 	 * Link source to the target.
995 	 */
996 	rw_enter(&tdp->i_rwlock, RW_WRITER);
997 	if (error = ud_direnter(tdp, tnm, DE_RENAME, sdp, sip,
998 	    (struct vattr *)0, (struct ud_inode **)0, cr, ct)) {
999 		/*
1000 		 * ESAME isn't really an error; it indicates that the
1001 		 * operation should not be done because the source and target
1002 		 * are the same file, but that no error should be reported.
1003 		 */
1004 		if (error == ESAME) {
1005 			error = 0;
1006 		}
1007 		rw_exit(&tdp->i_rwlock);
1008 		goto errout;
1009 	}
1010 	rw_exit(&tdp->i_rwlock);
1011 
1012 	rw_enter(&sdp->i_rwlock, RW_WRITER);
1013 	/*
1014 	 * Unlink the source.
1015 	 * Remove the source entry.  ud_dirremove() checks that the entry
1016 	 * still reflects sip, and returns an error if it doesn't.
1017 	 * If the entry has changed just forget about it.  Release
1018 	 * the source inode.
1019 	 */
1020 	if ((error = ud_dirremove(sdp, snm, sip, (struct vnode *)0,
1021 	    DR_RENAME, cr, ct)) == ENOENT) {
1022 		error = 0;
1023 	}
1024 	rw_exit(&sdp->i_rwlock);
1025 
1026 	if (error == 0) {
1027 		vnevent_rename_src(ITOV(sip), sdvp, snm, ct);
1028 		/*
1029 		 * vnevent_rename_dest and vnevent_rename_dest_dir are called
1030 		 * in ud_direnter().
1031 		 */
1032 	}
1033 
1034 errout:
1035 	ITIMES(sdp);
1036 	ITIMES(tdp);
1037 	VN_RELE(ITOV(sip));
1038 	mutex_exit(&udf_vfsp->udf_rename_lck);
1039 
1040 	return (error);
1041 }
1042 
1043 /* ARGSUSED */
1044 static int32_t
udf_mkdir(struct vnode * dvp,char * dirname,struct vattr * vap,struct vnode ** vpp,struct cred * cr,caller_context_t * ct,int flags,vsecattr_t * vsecp)1045 udf_mkdir(
1046 	struct vnode *dvp,
1047 	char *dirname,
1048 	struct vattr *vap,
1049 	struct vnode **vpp,
1050 	struct cred *cr,
1051 	caller_context_t *ct,
1052 	int flags,
1053 	vsecattr_t *vsecp)
1054 {
1055 	int32_t error;
1056 	struct ud_inode *ip;
1057 	struct ud_inode *xip;
1058 
1059 	ASSERT((vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE));
1060 
1061 	ud_printf("udf_mkdir\n");
1062 
1063 	ip = VTOI(dvp);
1064 	rw_enter(&ip->i_rwlock, RW_WRITER);
1065 	error = ud_direnter(ip, dirname, DE_MKDIR,
1066 	    (struct ud_inode *)0, (struct ud_inode *)0, vap, &xip, cr, ct);
1067 	rw_exit(&ip->i_rwlock);
1068 	ITIMES(ip);
1069 	if (error == 0) {
1070 		ip = xip;
1071 		*vpp = ITOV(ip);
1072 		ITIMES(ip);
1073 	} else if (error == EEXIST) {
1074 		ITIMES(xip);
1075 		VN_RELE(ITOV(xip));
1076 	}
1077 
1078 	return (error);
1079 }
1080 
1081 /* ARGSUSED */
1082 static int32_t
udf_rmdir(struct vnode * vp,char * nm,struct vnode * cdir,struct cred * cr,caller_context_t * ct,int flags)1083 udf_rmdir(
1084 	struct vnode *vp,
1085 	char *nm,
1086 	struct vnode *cdir,
1087 	struct cred *cr,
1088 	caller_context_t *ct,
1089 	int flags)
1090 {
1091 	int32_t error;
1092 	struct ud_inode *ip = VTOI(vp);
1093 
1094 	ud_printf("udf_rmdir\n");
1095 
1096 	rw_enter(&ip->i_rwlock, RW_WRITER);
1097 	error = ud_dirremove(ip, nm, (struct ud_inode *)0, cdir, DR_RMDIR,
1098 	    cr, ct);
1099 	rw_exit(&ip->i_rwlock);
1100 	ITIMES(ip);
1101 
1102 	return (error);
1103 }
1104 
1105 /* ARGSUSED */
1106 static int32_t
udf_readdir(struct vnode * vp,struct uio * uiop,struct cred * cr,int32_t * eofp,caller_context_t * ct,int flags)1107 udf_readdir(
1108 	struct vnode *vp,
1109 	struct uio *uiop,
1110 	struct cred *cr,
1111 	int32_t *eofp,
1112 	caller_context_t *ct,
1113 	int flags)
1114 {
1115 	struct ud_inode *ip;
1116 	struct dirent64 *nd;
1117 	struct udf_vfs *udf_vfsp;
1118 	int32_t error = 0, len, outcount = 0;
1119 	uint32_t dirsiz, offset;
1120 	uint32_t bufsize, ndlen, dummy;
1121 	caddr_t outbuf;
1122 	caddr_t outb, end_outb;
1123 	struct iovec *iovp;
1124 
1125 	uint8_t *dname;
1126 	int32_t length;
1127 
1128 	uint8_t *buf = NULL;
1129 
1130 	struct fbuf *fbp = NULL;
1131 	struct file_id *fid;
1132 	uint8_t *name;
1133 
1134 
1135 	ud_printf("udf_readdir\n");
1136 
1137 	ip = VTOI(vp);
1138 	udf_vfsp = ip->i_udf;
1139 
1140 	dirsiz = ip->i_size;
1141 	if ((uiop->uio_offset >= dirsiz) ||
1142 	    (ip->i_nlink <= 0)) {
1143 		if (eofp) {
1144 			*eofp = 1;
1145 		}
1146 		return (0);
1147 	}
1148 
1149 	offset = uiop->uio_offset;
1150 	iovp = uiop->uio_iov;
1151 	bufsize = iovp->iov_len;
1152 
1153 	outb = outbuf = (char *)kmem_alloc((uint32_t)bufsize, KM_SLEEP);
1154 	end_outb = outb + bufsize;
1155 	nd = (struct dirent64 *)outbuf;
1156 
1157 	dname = (uint8_t *)kmem_zalloc(1024, KM_SLEEP);
1158 	buf = (uint8_t *)kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP);
1159 
1160 	if (offset == 0) {
1161 		len = DIRENT64_RECLEN(1);
1162 		if (((caddr_t)nd + len) >= end_outb) {
1163 			error = EINVAL;
1164 			goto end;
1165 		}
1166 		nd->d_ino = ip->i_icb_lbano;
1167 		nd->d_reclen = (uint16_t)len;
1168 		nd->d_off = 0x10;
1169 		nd->d_name[0] = '.';
1170 		bzero(&nd->d_name[1], DIRENT64_NAMELEN(len) - 1);
1171 		nd = (struct dirent64 *)((char *)nd + nd->d_reclen);
1172 		outcount++;
1173 	} else if (offset == 0x10) {
1174 		offset = 0;
1175 	}
1176 
1177 	while (offset < dirsiz) {
1178 		error = ud_get_next_fid(ip, &fbp,
1179 		    offset, &fid, &name, buf);
1180 		if (error != 0) {
1181 			break;
1182 		}
1183 
1184 		if ((fid->fid_flags & FID_DELETED) == 0) {
1185 			if (fid->fid_flags & FID_PARENT) {
1186 
1187 				len = DIRENT64_RECLEN(2);
1188 				if (((caddr_t)nd + len) >= end_outb) {
1189 					error = EINVAL;
1190 					break;
1191 				}
1192 
1193 				nd->d_ino = ip->i_icb_lbano;
1194 				nd->d_reclen = (uint16_t)len;
1195 				nd->d_off = offset + FID_LEN(fid);
1196 				nd->d_name[0] = '.';
1197 				nd->d_name[1] = '.';
1198 				bzero(&nd->d_name[2],
1199 				    DIRENT64_NAMELEN(len) - 2);
1200 				nd = (struct dirent64 *)
1201 				    ((char *)nd + nd->d_reclen);
1202 			} else {
1203 				if ((error = ud_uncompress(fid->fid_idlen,
1204 				    &length, name, dname)) != 0) {
1205 					break;
1206 				}
1207 				if (length == 0) {
1208 					offset += FID_LEN(fid);
1209 					continue;
1210 				}
1211 				len = DIRENT64_RECLEN(length);
1212 				if (((caddr_t)nd + len) >= end_outb) {
1213 					if (!outcount) {
1214 						error = EINVAL;
1215 					}
1216 					break;
1217 				}
1218 				(void) strncpy(nd->d_name,
1219 				    (caddr_t)dname, length);
1220 				bzero(&nd->d_name[length],
1221 				    DIRENT64_NAMELEN(len) - length);
1222 				nd->d_ino = ud_xlate_to_daddr(udf_vfsp,
1223 				    SWAP_16(fid->fid_icb.lad_ext_prn),
1224 				    SWAP_32(fid->fid_icb.lad_ext_loc), 1,
1225 				    &dummy);
1226 				nd->d_reclen = (uint16_t)len;
1227 				nd->d_off = offset + FID_LEN(fid);
1228 				nd = (struct dirent64 *)
1229 				    ((char *)nd + nd->d_reclen);
1230 			}
1231 			outcount++;
1232 		}
1233 
1234 		offset += FID_LEN(fid);
1235 	}
1236 
1237 end:
1238 	if (fbp != NULL) {
1239 		fbrelse(fbp, S_OTHER);
1240 	}
1241 	ndlen = ((char *)nd - outbuf);
1242 	/*
1243 	 * In case of error do not call uiomove.
1244 	 * Return the error to the caller.
1245 	 */
1246 	if ((error == 0) && (ndlen != 0)) {
1247 		error = uiomove(outbuf, (long)ndlen, UIO_READ, uiop);
1248 		uiop->uio_offset = offset;
1249 	}
1250 	kmem_free((caddr_t)buf, udf_vfsp->udf_lbsize);
1251 	kmem_free((caddr_t)dname, 1024);
1252 	kmem_free(outbuf, (uint32_t)bufsize);
1253 	if (eofp && error == 0) {
1254 		*eofp = (uiop->uio_offset >= dirsiz);
1255 	}
1256 	return (error);
1257 }
1258 
1259 /* ARGSUSED */
1260 static int32_t
udf_symlink(struct vnode * dvp,char * linkname,struct vattr * vap,char * target,struct cred * cr,caller_context_t * ct,int flags)1261 udf_symlink(
1262 	struct vnode *dvp,
1263 	char *linkname,
1264 	struct vattr *vap,
1265 	char *target,
1266 	struct cred *cr,
1267 	caller_context_t *ct,
1268 	int flags)
1269 {
1270 	int32_t error = 0, outlen;
1271 	uint32_t ioflag = 0;
1272 	struct ud_inode *ip, *dip = VTOI(dvp);
1273 
1274 	struct path_comp *pc;
1275 	int8_t *dname = NULL, *uname = NULL, *sp;
1276 
1277 	ud_printf("udf_symlink\n");
1278 
1279 	ip = (struct ud_inode *)0;
1280 	vap->va_type = VLNK;
1281 	vap->va_rdev = 0;
1282 
1283 	rw_enter(&dip->i_rwlock, RW_WRITER);
1284 	error = ud_direnter(dip, linkname, DE_CREATE,
1285 	    (struct ud_inode *)0, (struct ud_inode *)0, vap, &ip, cr, ct);
1286 	rw_exit(&dip->i_rwlock);
1287 	if (error == 0) {
1288 		dname = kmem_zalloc(1024, KM_SLEEP);
1289 		uname = kmem_zalloc(PAGESIZE, KM_SLEEP);
1290 
1291 		pc = (struct path_comp *)uname;
1292 		/*
1293 		 * If the first character in target is "/"
1294 		 * then skip it and create entry for it
1295 		 */
1296 		if (*target == '/') {
1297 			pc->pc_type = 2;
1298 			pc->pc_len = 0;
1299 			pc = (struct path_comp *)(((char *)pc) + 4);
1300 			while (*target == '/') {
1301 				target++;
1302 			}
1303 		}
1304 
1305 		while (*target != '\0') {
1306 			sp = target;
1307 			while ((*target != '/') && (*target != '\0')) {
1308 				target ++;
1309 			}
1310 			/*
1311 			 * We got the next component of the
1312 			 * path name. Create path_comp of
1313 			 * appropriate type
1314 			 */
1315 			if (((target - sp) == 1) && (*sp == '.')) {
1316 				/*
1317 				 * Dot entry.
1318 				 */
1319 				pc->pc_type = 4;
1320 				pc = (struct path_comp *)(((char *)pc) + 4);
1321 			} else if (((target - sp) == 2) &&
1322 			    (*sp == '.') && ((*(sp + 1)) == '.')) {
1323 				/*
1324 				 * DotDot entry.
1325 				 */
1326 				pc->pc_type = 3;
1327 				pc = (struct path_comp *)(((char *)pc) + 4);
1328 			} else {
1329 				/*
1330 				 * convert the user given name
1331 				 * into appropriate form to be put
1332 				 * on the media
1333 				 */
1334 				outlen = 1024;	/* set to size of dname */
1335 				if (error = ud_compress(target - sp, &outlen,
1336 				    (uint8_t *)sp, (uint8_t *)dname)) {
1337 					break;
1338 				}
1339 				pc->pc_type = 5;
1340 				/* LINTED */
1341 				pc->pc_len = outlen;
1342 				dname[outlen] = '\0';
1343 				(void) strcpy((char *)pc->pc_id, dname);
1344 				pc = (struct path_comp *)
1345 				    (((char *)pc) + 4 + outlen);
1346 			}
1347 			while (*target == '/') {
1348 				target++;
1349 			}
1350 			if (*target == '\0') {
1351 				break;
1352 			}
1353 		}
1354 
1355 		rw_enter(&ip->i_contents, RW_WRITER);
1356 		if (error == 0) {
1357 			ioflag = FWRITE;
1358 			if (curthread->t_flag & T_DONTPEND) {
1359 				ioflag |= FDSYNC;
1360 			}
1361 			error = ud_rdwri(UIO_WRITE, ioflag, ip,
1362 			    uname, ((int8_t *)pc) - uname,
1363 			    (offset_t)0, UIO_SYSSPACE, (int32_t *)0, cr);
1364 		}
1365 		if (error) {
1366 			ud_idrop(ip);
1367 			rw_exit(&ip->i_contents);
1368 			rw_enter(&dip->i_rwlock, RW_WRITER);
1369 			(void) ud_dirremove(dip, linkname, (struct ud_inode *)0,
1370 			    (struct vnode *)0, DR_REMOVE, cr, ct);
1371 			rw_exit(&dip->i_rwlock);
1372 			goto update_inode;
1373 		}
1374 		rw_exit(&ip->i_contents);
1375 	}
1376 
1377 	if ((error == 0) || (error == EEXIST)) {
1378 		VN_RELE(ITOV(ip));
1379 	}
1380 
1381 update_inode:
1382 	ITIMES(VTOI(dvp));
1383 	if (uname != NULL) {
1384 		kmem_free(uname, PAGESIZE);
1385 	}
1386 	if (dname != NULL) {
1387 		kmem_free(dname, 1024);
1388 	}
1389 
1390 	return (error);
1391 }
1392 
1393 /* ARGSUSED */
1394 static int32_t
udf_readlink(struct vnode * vp,struct uio * uiop,struct cred * cr,caller_context_t * ct)1395 udf_readlink(
1396 	struct vnode *vp,
1397 	struct uio *uiop,
1398 	struct cred *cr,
1399 	caller_context_t *ct)
1400 {
1401 	int32_t error = 0, off, id_len, size, len;
1402 	int8_t *dname = NULL, *uname = NULL;
1403 	struct ud_inode *ip;
1404 	struct fbuf *fbp = NULL;
1405 	struct path_comp *pc;
1406 
1407 	ud_printf("udf_readlink\n");
1408 
1409 	if (vp->v_type != VLNK) {
1410 		return (EINVAL);
1411 	}
1412 
1413 	ip = VTOI(vp);
1414 	size = ip->i_size;
1415 	if (size > PAGESIZE) {
1416 		return (EIO);
1417 	}
1418 
1419 	if (size == 0) {
1420 		return (0);
1421 	}
1422 
1423 	dname = kmem_zalloc(1024, KM_SLEEP);
1424 	uname = kmem_zalloc(PAGESIZE, KM_SLEEP);
1425 
1426 	rw_enter(&ip->i_contents, RW_READER);
1427 
1428 	if ((error = fbread(vp, 0, size, S_READ, &fbp)) != 0) {
1429 		goto end;
1430 	}
1431 
1432 	off = 0;
1433 
1434 	while (off < size) {
1435 		pc = (struct path_comp *)(fbp->fb_addr + off);
1436 		switch (pc->pc_type) {
1437 			case 1 :
1438 				(void) strcpy(uname, ip->i_udf->udf_fsmnt);
1439 				(void) strcat(uname, "/");
1440 				break;
1441 			case 2 :
1442 				if (pc->pc_len != 0) {
1443 					goto end;
1444 				}
1445 				uname[0] = '/';
1446 				uname[1] = '\0';
1447 				break;
1448 			case 3 :
1449 				(void) strcat(uname, "../");
1450 				break;
1451 			case 4 :
1452 				(void) strcat(uname, "./");
1453 				break;
1454 			case 5 :
1455 				if ((error = ud_uncompress(pc->pc_len, &id_len,
1456 				    pc->pc_id, (uint8_t *)dname)) != 0) {
1457 					break;
1458 				}
1459 				dname[id_len] = '\0';
1460 				(void) strcat(uname, dname);
1461 				(void) strcat(uname, "/");
1462 				break;
1463 			default :
1464 				error = EINVAL;
1465 				goto end;
1466 		}
1467 		off += 4 + pc->pc_len;
1468 	}
1469 	len = strlen(uname) - 1;
1470 	if (uname[len] == '/') {
1471 		if (len == 0) {
1472 			/*
1473 			 * special case link to /
1474 			 */
1475 			len = 1;
1476 		} else {
1477 			uname[len] = '\0';
1478 		}
1479 	}
1480 
1481 	error = uiomove(uname, len, UIO_READ, uiop);
1482 
1483 	ITIMES(ip);
1484 
1485 end:
1486 	if (fbp != NULL) {
1487 		fbrelse(fbp, S_OTHER);
1488 	}
1489 	rw_exit(&ip->i_contents);
1490 	if (uname != NULL) {
1491 		kmem_free(uname, PAGESIZE);
1492 	}
1493 	if (dname != NULL) {
1494 		kmem_free(dname, 1024);
1495 	}
1496 	return (error);
1497 }
1498 
1499 /* ARGSUSED */
1500 static int32_t
udf_fsync(struct vnode * vp,int32_t syncflag,struct cred * cr,caller_context_t * ct)1501 udf_fsync(
1502 	struct vnode *vp,
1503 	int32_t syncflag,
1504 	struct cred *cr,
1505 	caller_context_t *ct)
1506 {
1507 	int32_t error = 0;
1508 	struct ud_inode *ip = VTOI(vp);
1509 
1510 	ud_printf("udf_fsync\n");
1511 
1512 	rw_enter(&ip->i_contents, RW_WRITER);
1513 	if (!(IS_SWAPVP(vp))) {
1514 		error = ud_syncip(ip, 0, I_SYNC); /* Do synchronous writes */
1515 	}
1516 	if (error == 0) {
1517 		error = ud_sync_indir(ip);
1518 	}
1519 	ITIMES(ip);		/* XXX: is this necessary ??? */
1520 	rw_exit(&ip->i_contents);
1521 
1522 	return (error);
1523 }
1524 
1525 /* ARGSUSED */
1526 static void
udf_inactive(struct vnode * vp,struct cred * cr,caller_context_t * ct)1527 udf_inactive(struct vnode *vp, struct cred *cr, caller_context_t *ct)
1528 {
1529 	ud_printf("udf_iinactive\n");
1530 
1531 	ud_iinactive(VTOI(vp), cr);
1532 }
1533 
1534 /* ARGSUSED */
1535 static int32_t
udf_fid(struct vnode * vp,struct fid * fidp,caller_context_t * ct)1536 udf_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct)
1537 {
1538 	struct udf_fid *udfidp;
1539 	struct ud_inode *ip = VTOI(vp);
1540 
1541 	ud_printf("udf_fid\n");
1542 
1543 	if (fidp->fid_len < (sizeof (struct udf_fid) - sizeof (uint16_t))) {
1544 		fidp->fid_len = sizeof (struct udf_fid) - sizeof (uint16_t);
1545 		return (ENOSPC);
1546 	}
1547 
1548 	udfidp = (struct udf_fid *)fidp;
1549 	bzero((char *)udfidp, sizeof (struct udf_fid));
1550 	rw_enter(&ip->i_contents, RW_READER);
1551 	udfidp->udfid_len = sizeof (struct udf_fid) - sizeof (uint16_t);
1552 	udfidp->udfid_uinq_lo = ip->i_uniqid & 0xffffffff;
1553 	udfidp->udfid_prn = ip->i_icb_prn;
1554 	udfidp->udfid_icb_lbn = ip->i_icb_block;
1555 	rw_exit(&ip->i_contents);
1556 
1557 	return (0);
1558 }
1559 
1560 /* ARGSUSED2 */
1561 static int
udf_rwlock(struct vnode * vp,int32_t write_lock,caller_context_t * ctp)1562 udf_rwlock(struct vnode *vp, int32_t write_lock, caller_context_t *ctp)
1563 {
1564 	struct ud_inode *ip = VTOI(vp);
1565 
1566 	ud_printf("udf_rwlock\n");
1567 
1568 	if (write_lock) {
1569 		rw_enter(&ip->i_rwlock, RW_WRITER);
1570 	} else {
1571 		rw_enter(&ip->i_rwlock, RW_READER);
1572 	}
1573 #ifdef	__lock_lint
1574 	rw_exit(&ip->i_rwlock);
1575 #endif
1576 	return (write_lock);
1577 }
1578 
1579 /* ARGSUSED */
1580 static void
udf_rwunlock(struct vnode * vp,int32_t write_lock,caller_context_t * ctp)1581 udf_rwunlock(struct vnode *vp, int32_t write_lock, caller_context_t *ctp)
1582 {
1583 	struct ud_inode *ip = VTOI(vp);
1584 
1585 	ud_printf("udf_rwunlock\n");
1586 
1587 #ifdef	__lock_lint
1588 	rw_enter(&ip->i_rwlock, RW_WRITER);
1589 #endif
1590 
1591 	rw_exit(&ip->i_rwlock);
1592 
1593 }
1594 
1595 /* ARGSUSED */
1596 static int32_t
udf_seek(struct vnode * vp,offset_t ooff,offset_t * noffp,caller_context_t * ct)1597 udf_seek(struct vnode *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)
1598 {
1599 	return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);
1600 }
1601 
1602 static int32_t
udf_frlock(struct vnode * vp,int32_t cmd,struct flock64 * bfp,int32_t flag,offset_t offset,struct flk_callback * flk_cbp,cred_t * cr,caller_context_t * ct)1603 udf_frlock(
1604 	struct vnode *vp,
1605 	int32_t cmd,
1606 	struct flock64 *bfp,
1607 	int32_t flag,
1608 	offset_t offset,
1609 	struct flk_callback *flk_cbp,
1610 	cred_t *cr,
1611 	caller_context_t *ct)
1612 {
1613 	struct ud_inode *ip = VTOI(vp);
1614 
1615 	ud_printf("udf_frlock\n");
1616 
1617 	/*
1618 	 * If file is being mapped, disallow frlock.
1619 	 * XXX I am not holding tlock while checking i_mapcnt because the
1620 	 * current locking strategy drops all locks before calling fs_frlock.
1621 	 * So, mapcnt could change before we enter fs_frlock making is
1622 	 * meaningless to have held tlock in the first place.
1623 	 */
1624 	if ((ip->i_mapcnt > 0) &&
1625 	    (MANDLOCK(vp, ip->i_char))) {
1626 		return (EAGAIN);
1627 	}
1628 
1629 	return (fs_frlock(vp, cmd, bfp, flag, offset, flk_cbp, cr, ct));
1630 }
1631 
1632 /*ARGSUSED6*/
1633 static int32_t
udf_space(struct vnode * vp,int32_t cmd,struct flock64 * bfp,int32_t flag,offset_t offset,cred_t * cr,caller_context_t * ct)1634 udf_space(
1635 	struct vnode *vp,
1636 	int32_t cmd,
1637 	struct flock64 *bfp,
1638 	int32_t flag,
1639 	offset_t offset,
1640 	cred_t *cr,
1641 	caller_context_t *ct)
1642 {
1643 	int32_t error = 0;
1644 
1645 	ud_printf("udf_space\n");
1646 
1647 	if (cmd != F_FREESP) {
1648 		error =  EINVAL;
1649 	} else if ((error = convoff(vp, bfp, 0, offset)) == 0) {
1650 		error = ud_freesp(vp, bfp, flag, cr);
1651 
1652 		if (error == 0 && bfp->l_start == 0)
1653 			vnevent_truncate(vp, ct);
1654 	}
1655 
1656 	return (error);
1657 }
1658 
1659 /* ARGSUSED */
1660 static int32_t
udf_getpage(struct vnode * vp,offset_t off,size_t len,uint32_t * protp,struct page ** plarr,size_t plsz,struct seg * seg,caddr_t addr,enum seg_rw rw,struct cred * cr,caller_context_t * ct)1661 udf_getpage(
1662 	struct vnode *vp,
1663 	offset_t off,
1664 	size_t len,
1665 	uint32_t *protp,
1666 	struct page **plarr,
1667 	size_t plsz,
1668 	struct seg *seg,
1669 	caddr_t addr,
1670 	enum seg_rw rw,
1671 	struct cred *cr,
1672 	caller_context_t *ct)
1673 {
1674 	struct ud_inode *ip = VTOI(vp);
1675 	int32_t error, has_holes, beyond_eof, seqmode, dolock;
1676 	int32_t pgsize = PAGESIZE;
1677 	struct udf_vfs *udf_vfsp = ip->i_udf;
1678 	page_t **pl;
1679 	u_offset_t pgoff, eoff, uoff;
1680 	krw_t rwtype;
1681 	caddr_t pgaddr;
1682 
1683 	ud_printf("udf_getpage\n");
1684 
1685 	uoff = (u_offset_t)off; /* type conversion */
1686 	if (protp) {
1687 		*protp = PROT_ALL;
1688 	}
1689 	if (vp->v_flag & VNOMAP) {
1690 		return (ENOSYS);
1691 	}
1692 	seqmode = ip->i_nextr == uoff && rw != S_CREATE;
1693 
1694 	rwtype = RW_READER;
1695 	dolock = (rw_owner(&ip->i_contents) != curthread);
1696 retrylock:
1697 #ifdef	__lock_lint
1698 	rw_enter(&ip->i_contents, rwtype);
1699 #else
1700 	if (dolock) {
1701 		rw_enter(&ip->i_contents, rwtype);
1702 	}
1703 #endif
1704 
1705 	/*
1706 	 * We may be getting called as a side effect of a bmap using
1707 	 * fbread() when the blocks might be being allocated and the
1708 	 * size has not yet been up'ed.  In this case we want to be
1709 	 * able to return zero pages if we get back UDF_HOLE from
1710 	 * calling bmap for a non write case here.  We also might have
1711 	 * to read some frags from the disk into a page if we are
1712 	 * extending the number of frags for a given lbn in bmap().
1713 	 */
1714 	beyond_eof = uoff + len > ip->i_size + PAGEOFFSET;
1715 	if (beyond_eof && seg != segkmap) {
1716 #ifdef	__lock_lint
1717 		rw_exit(&ip->i_contents);
1718 #else
1719 		if (dolock) {
1720 			rw_exit(&ip->i_contents);
1721 		}
1722 #endif
1723 		return (EFAULT);
1724 	}
1725 
1726 	/*
1727 	 * Must hold i_contents lock throughout the call to pvn_getpages
1728 	 * since locked pages are returned from each call to ud_getapage.
1729 	 * Must *not* return locked pages and then try for contents lock
1730 	 * due to lock ordering requirements (inode > page)
1731 	 */
1732 
1733 	has_holes = ud_bmap_has_holes(ip);
1734 
1735 	if ((rw == S_WRITE || rw == S_CREATE) && (has_holes || beyond_eof)) {
1736 		int32_t	blk_size, count;
1737 		u_offset_t offset;
1738 
1739 		/*
1740 		 * We must acquire the RW_WRITER lock in order to
1741 		 * call bmap_write().
1742 		 */
1743 		if (dolock && rwtype == RW_READER) {
1744 			rwtype = RW_WRITER;
1745 
1746 			if (!rw_tryupgrade(&ip->i_contents)) {
1747 
1748 				rw_exit(&ip->i_contents);
1749 
1750 				goto retrylock;
1751 			}
1752 		}
1753 
1754 		/*
1755 		 * May be allocating disk blocks for holes here as
1756 		 * a result of mmap faults. write(2) does the bmap_write
1757 		 * in rdip/wrip, not here. We are not dealing with frags
1758 		 * in this case.
1759 		 */
1760 		offset = uoff;
1761 		while ((offset < uoff + len) &&
1762 		    (offset < ip->i_size)) {
1763 			/*
1764 			 * the variable "bnp" is to simplify the expression for
1765 			 * the compiler; * just passing in &bn to bmap_write
1766 			 * causes a compiler "loop"
1767 			 */
1768 
1769 			blk_size = udf_vfsp->udf_lbsize;
1770 			if ((offset + blk_size) > ip->i_size) {
1771 				count = ip->i_size - offset;
1772 			} else {
1773 				count = blk_size;
1774 			}
1775 			error = ud_bmap_write(ip, offset, count, 0, cr);
1776 			if (error) {
1777 				goto update_inode;
1778 			}
1779 			offset += count; /* XXX - make this contig */
1780 		}
1781 	}
1782 
1783 	/*
1784 	 * Can be a reader from now on.
1785 	 */
1786 #ifdef	__lock_lint
1787 	if (rwtype == RW_WRITER) {
1788 		rw_downgrade(&ip->i_contents);
1789 	}
1790 #else
1791 	if (dolock && rwtype == RW_WRITER) {
1792 		rw_downgrade(&ip->i_contents);
1793 	}
1794 #endif
1795 
1796 	/*
1797 	 * We remove PROT_WRITE in cases when the file has UDF holes
1798 	 * because we don't  want to call bmap_read() to check each
1799 	 * page if it is backed with a disk block.
1800 	 */
1801 	if (protp && has_holes && rw != S_WRITE && rw != S_CREATE) {
1802 		*protp &= ~PROT_WRITE;
1803 	}
1804 
1805 	error = 0;
1806 
1807 	/*
1808 	 * The loop looks up pages in the range <off, off + len).
1809 	 * For each page, we first check if we should initiate an asynchronous
1810 	 * read ahead before we call page_lookup (we may sleep in page_lookup
1811 	 * for a previously initiated disk read).
1812 	 */
1813 	eoff = (uoff + len);
1814 	for (pgoff = uoff, pgaddr = addr, pl = plarr;
1815 	    pgoff < eoff; /* empty */) {
1816 		page_t	*pp;
1817 		u_offset_t	nextrio;
1818 		se_t	se;
1819 
1820 		se = ((rw == S_CREATE) ? SE_EXCL : SE_SHARED);
1821 
1822 		/*
1823 		 * Handle async getpage (faultahead)
1824 		 */
1825 		if (plarr == NULL) {
1826 			ip->i_nextrio = pgoff;
1827 			ud_getpage_ra(vp, pgoff, seg, pgaddr);
1828 			pgoff += pgsize;
1829 			pgaddr += pgsize;
1830 			continue;
1831 		}
1832 
1833 		/*
1834 		 * Check if we should initiate read ahead of next cluster.
1835 		 * We call page_exists only when we need to confirm that
1836 		 * we have the current page before we initiate the read ahead.
1837 		 */
1838 		nextrio = ip->i_nextrio;
1839 		if (seqmode &&
1840 		    pgoff + RD_CLUSTSZ(ip) >= nextrio && pgoff <= nextrio &&
1841 		    nextrio < ip->i_size && page_exists(vp, pgoff))
1842 			ud_getpage_ra(vp, pgoff, seg, pgaddr);
1843 
1844 		if ((pp = page_lookup(vp, pgoff, se)) != NULL) {
1845 
1846 			/*
1847 			 * We found the page in the page cache.
1848 			 */
1849 			*pl++ = pp;
1850 			pgoff += pgsize;
1851 			pgaddr += pgsize;
1852 			len -= pgsize;
1853 			plsz -= pgsize;
1854 		} else  {
1855 
1856 			/*
1857 			 * We have to create the page, or read it from disk.
1858 			 */
1859 			if (error = ud_getpage_miss(vp, pgoff, len,
1860 			    seg, pgaddr, pl, plsz, rw, seqmode)) {
1861 				goto error_out;
1862 			}
1863 
1864 			while (*pl != NULL) {
1865 				pl++;
1866 				pgoff += pgsize;
1867 				pgaddr += pgsize;
1868 				len -= pgsize;
1869 				plsz -= pgsize;
1870 			}
1871 		}
1872 	}
1873 
1874 	/*
1875 	 * Return pages up to plsz if they are in the page cache.
1876 	 * We cannot return pages if there is a chance that they are
1877 	 * backed with a UDF hole and rw is S_WRITE or S_CREATE.
1878 	 */
1879 	if (plarr && !(has_holes && (rw == S_WRITE || rw == S_CREATE))) {
1880 
1881 		ASSERT((protp == NULL) ||
1882 		    !(has_holes && (*protp & PROT_WRITE)));
1883 
1884 		eoff = pgoff + plsz;
1885 		while (pgoff < eoff) {
1886 			page_t		*pp;
1887 
1888 			if ((pp = page_lookup_nowait(vp, pgoff,
1889 			    SE_SHARED)) == NULL)
1890 				break;
1891 
1892 			*pl++ = pp;
1893 			pgoff += pgsize;
1894 			plsz -= pgsize;
1895 		}
1896 	}
1897 
1898 	if (plarr)
1899 		*pl = NULL;			/* Terminate page list */
1900 	ip->i_nextr = pgoff;
1901 
1902 error_out:
1903 	if (error && plarr) {
1904 		/*
1905 		 * Release any pages we have locked.
1906 		 */
1907 		while (pl > &plarr[0])
1908 			page_unlock(*--pl);
1909 
1910 		plarr[0] = NULL;
1911 	}
1912 
1913 update_inode:
1914 #ifdef	__lock_lint
1915 	rw_exit(&ip->i_contents);
1916 #else
1917 	if (dolock) {
1918 		rw_exit(&ip->i_contents);
1919 	}
1920 #endif
1921 
1922 	/*
1923 	 * If the inode is not already marked for IACC (in rwip() for read)
1924 	 * and the inode is not marked for no access time update (in rwip()
1925 	 * for write) then update the inode access time and mod time now.
1926 	 */
1927 	mutex_enter(&ip->i_tlock);
1928 	if ((ip->i_flag & (IACC | INOACC)) == 0) {
1929 		if ((rw != S_OTHER) && (ip->i_type != VDIR)) {
1930 			ip->i_flag |= IACC;
1931 		}
1932 		if (rw == S_WRITE) {
1933 			ip->i_flag |= IUPD;
1934 		}
1935 		ITIMES_NOLOCK(ip);
1936 	}
1937 	mutex_exit(&ip->i_tlock);
1938 
1939 	return (error);
1940 }
1941 
1942 int32_t ud_delay = 1;
1943 
1944 /* ARGSUSED */
1945 static int32_t
udf_putpage(struct vnode * vp,offset_t off,size_t len,int32_t flags,struct cred * cr,caller_context_t * ct)1946 udf_putpage(
1947 	struct vnode *vp,
1948 	offset_t off,
1949 	size_t len,
1950 	int32_t flags,
1951 	struct cred *cr,
1952 	caller_context_t *ct)
1953 {
1954 	struct ud_inode *ip;
1955 	int32_t error = 0;
1956 
1957 	ud_printf("udf_putpage\n");
1958 
1959 	ip = VTOI(vp);
1960 #ifdef	__lock_lint
1961 	rw_enter(&ip->i_contents, RW_WRITER);
1962 #endif
1963 
1964 	if (vp->v_count == 0) {
1965 		cmn_err(CE_WARN, "ud_putpage : bad v_count");
1966 		error = EINVAL;
1967 		goto out;
1968 	}
1969 
1970 	if (vp->v_flag & VNOMAP) {
1971 		error = ENOSYS;
1972 		goto out;
1973 	}
1974 
1975 	if (flags & B_ASYNC) {
1976 		if (ud_delay && len &&
1977 		    (flags & ~(B_ASYNC|B_DONTNEED|B_FREE)) == 0) {
1978 			mutex_enter(&ip->i_tlock);
1979 
1980 			/*
1981 			 * If nobody stalled, start a new cluster.
1982 			 */
1983 			if (ip->i_delaylen == 0) {
1984 				ip->i_delayoff = off;
1985 				ip->i_delaylen = len;
1986 				mutex_exit(&ip->i_tlock);
1987 				goto out;
1988 			}
1989 
1990 			/*
1991 			 * If we have a full cluster or they are not contig,
1992 			 * then push last cluster and start over.
1993 			 */
1994 			if (ip->i_delaylen >= WR_CLUSTSZ(ip) ||
1995 			    ip->i_delayoff + ip->i_delaylen != off) {
1996 				u_offset_t doff;
1997 				size_t dlen;
1998 
1999 				doff = ip->i_delayoff;
2000 				dlen = ip->i_delaylen;
2001 				ip->i_delayoff = off;
2002 				ip->i_delaylen = len;
2003 				mutex_exit(&ip->i_tlock);
2004 				error = ud_putpages(vp, doff, dlen, flags, cr);
2005 				/* LMXXX - flags are new val, not old */
2006 				goto out;
2007 			}
2008 
2009 			/*
2010 			 * There is something there, it's not full, and
2011 			 * it is contig.
2012 			 */
2013 			ip->i_delaylen += len;
2014 			mutex_exit(&ip->i_tlock);
2015 			goto out;
2016 		}
2017 
2018 		/*
2019 		 * Must have weird flags or we are not clustering.
2020 		 */
2021 	}
2022 
2023 	error = ud_putpages(vp, off, len, flags, cr);
2024 
2025 out:
2026 #ifdef	__lock_lint
2027 	rw_exit(&ip->i_contents);
2028 #endif
2029 	return (error);
2030 }
2031 
2032 /* ARGSUSED */
2033 static int32_t
udf_map(struct vnode * vp,offset_t off,struct as * as,caddr_t * addrp,size_t len,uint8_t prot,uint8_t maxprot,uint32_t flags,struct cred * cr,caller_context_t * ct)2034 udf_map(
2035 	struct vnode *vp,
2036 	offset_t off,
2037 	struct as *as,
2038 	caddr_t *addrp,
2039 	size_t len,
2040 	uint8_t prot,
2041 	uint8_t maxprot,
2042 	uint32_t flags,
2043 	struct cred *cr,
2044 	caller_context_t *ct)
2045 {
2046 	struct segvn_crargs vn_a;
2047 	int32_t error = 0;
2048 
2049 	ud_printf("udf_map\n");
2050 
2051 	if (vp->v_flag & VNOMAP) {
2052 		error = ENOSYS;
2053 		goto end;
2054 	}
2055 
2056 	if ((off < (offset_t)0) ||
2057 	    ((off + len) < (offset_t)0)) {
2058 		error = EINVAL;
2059 		goto end;
2060 	}
2061 
2062 	if (vp->v_type != VREG) {
2063 		error = ENODEV;
2064 		goto end;
2065 	}
2066 
2067 	/*
2068 	 * If file is being locked, disallow mapping.
2069 	 */
2070 	if (vn_has_mandatory_locks(vp, VTOI(vp)->i_char)) {
2071 		error = EAGAIN;
2072 		goto end;
2073 	}
2074 
2075 	as_rangelock(as);
2076 	error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
2077 	if (error != 0) {
2078 		as_rangeunlock(as);
2079 		goto end;
2080 	}
2081 
2082 	vn_a.vp = vp;
2083 	vn_a.offset = off;
2084 	vn_a.type = flags & MAP_TYPE;
2085 	vn_a.prot = prot;
2086 	vn_a.maxprot = maxprot;
2087 	vn_a.cred = cr;
2088 	vn_a.amp = NULL;
2089 	vn_a.flags = flags & ~MAP_TYPE;
2090 	vn_a.szc = 0;
2091 	vn_a.lgrp_mem_policy_flags = 0;
2092 
2093 	error = as_map(as, *addrp, len, segvn_create, (caddr_t)&vn_a);
2094 	as_rangeunlock(as);
2095 
2096 end:
2097 	return (error);
2098 }
2099 
2100 /* ARGSUSED */
2101 static int32_t
udf_addmap(struct vnode * vp,offset_t off,struct as * as,caddr_t addr,size_t len,uint8_t prot,uint8_t maxprot,uint32_t flags,struct cred * cr,caller_context_t * ct)2102 udf_addmap(struct vnode *vp, offset_t off, struct as *as, caddr_t addr,
2103     size_t len, uint8_t prot, uint8_t maxprot, uint32_t flags,
2104     struct cred *cr, caller_context_t *ct)
2105 {
2106 	struct ud_inode *ip = VTOI(vp);
2107 
2108 	ud_printf("udf_addmap\n");
2109 
2110 	if (vp->v_flag & VNOMAP) {
2111 		return (ENOSYS);
2112 	}
2113 
2114 	mutex_enter(&ip->i_tlock);
2115 	ip->i_mapcnt += btopr(len);
2116 	mutex_exit(&ip->i_tlock);
2117 
2118 	return (0);
2119 }
2120 
2121 /* ARGSUSED */
2122 static int32_t
udf_delmap(struct vnode * vp,offset_t off,struct as * as,caddr_t addr,size_t len,uint32_t prot,uint32_t maxprot,uint32_t flags,struct cred * cr,caller_context_t * ct)2123 udf_delmap(struct vnode *vp, offset_t off, struct as *as, caddr_t addr,
2124     size_t len, uint32_t prot, uint32_t maxprot, uint32_t flags,
2125     struct cred *cr, caller_context_t *ct)
2126 {
2127 	struct ud_inode *ip = VTOI(vp);
2128 
2129 	ud_printf("udf_delmap\n");
2130 
2131 	if (vp->v_flag & VNOMAP) {
2132 		return (ENOSYS);
2133 	}
2134 
2135 	mutex_enter(&ip->i_tlock);
2136 	ip->i_mapcnt -= btopr(len);	/* Count released mappings */
2137 	ASSERT(ip->i_mapcnt >= 0);
2138 	mutex_exit(&ip->i_tlock);
2139 
2140 	return (0);
2141 }
2142 
2143 /* ARGSUSED */
2144 static int32_t
udf_l_pathconf(struct vnode * vp,int32_t cmd,ulong_t * valp,struct cred * cr,caller_context_t * ct)2145 udf_l_pathconf(struct vnode *vp, int32_t cmd, ulong_t *valp, struct cred *cr,
2146     caller_context_t *ct)
2147 {
2148 	int32_t error = 0;
2149 
2150 	ud_printf("udf_l_pathconf\n");
2151 
2152 	if (cmd == _PC_FILESIZEBITS) {
2153 		/*
2154 		 * udf supports 64 bits as file size
2155 		 * but there are several other restrictions
2156 		 * it only supports 32-bit block numbers and
2157 		 * daddr32_t is only and int32_t so taking these
2158 		 * into account we can stay just as where ufs is
2159 		 */
2160 		*valp = 41;
2161 	} else if (cmd == _PC_TIMESTAMP_RESOLUTION) {
2162 		/* nanosecond timestamp resolution */
2163 		*valp = 1L;
2164 	} else {
2165 		error = fs_pathconf(vp, cmd, valp, cr, ct);
2166 	}
2167 
2168 	return (error);
2169 }
2170 
2171 uint32_t ud_pageio_reads = 0, ud_pageio_writes = 0;
2172 #ifndef	__lint
2173 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", ud_pageio_reads))
2174 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", ud_pageio_writes))
2175 #endif
2176 /*
2177  * Assumption is that there will not be a pageio request
2178  * to a enbedded file
2179  */
2180 /* ARGSUSED */
2181 static int32_t
udf_pageio(struct vnode * vp,struct page * pp,u_offset_t io_off,size_t io_len,int32_t flags,struct cred * cr,caller_context_t * ct)2182 udf_pageio(
2183 	struct vnode *vp,
2184 	struct page *pp,
2185 	u_offset_t io_off,
2186 	size_t io_len,
2187 	int32_t flags,
2188 	struct cred *cr,
2189 	caller_context_t *ct)
2190 {
2191 	daddr_t bn;
2192 	struct buf *bp;
2193 	struct ud_inode *ip = VTOI(vp);
2194 	int32_t dolock, error = 0, contig, multi_io;
2195 	size_t done_len = 0, cur_len = 0;
2196 	page_t *npp = NULL, *opp = NULL, *cpp = pp;
2197 
2198 	if (pp == NULL) {
2199 		return (EINVAL);
2200 	}
2201 
2202 	dolock = (rw_owner(&ip->i_contents) != curthread);
2203 
2204 	/*
2205 	 * We need a better check.  Ideally, we would use another
2206 	 * vnodeops so that hlocked and forcibly unmounted file
2207 	 * systems would return EIO where appropriate and w/o the
2208 	 * need for these checks.
2209 	 */
2210 	if (ip->i_udf == NULL) {
2211 		return (EIO);
2212 	}
2213 
2214 #ifdef	__lock_lint
2215 	rw_enter(&ip->i_contents, RW_READER);
2216 #else
2217 	if (dolock) {
2218 		rw_enter(&ip->i_contents, RW_READER);
2219 	}
2220 #endif
2221 
2222 	/*
2223 	 * Break the io request into chunks, one for each contiguous
2224 	 * stretch of disk blocks in the target file.
2225 	 */
2226 	while (done_len < io_len) {
2227 		ASSERT(cpp);
2228 		bp = NULL;
2229 		contig = 0;
2230 		if (error = ud_bmap_read(ip, (u_offset_t)(io_off + done_len),
2231 		    &bn, &contig)) {
2232 			break;
2233 		}
2234 
2235 		if (bn == UDF_HOLE) {   /* No holey swapfiles */
2236 			cmn_err(CE_WARN, "SWAP file has HOLES");
2237 			error = EINVAL;
2238 			break;
2239 		}
2240 
2241 		cur_len = MIN(io_len - done_len, contig);
2242 
2243 		/*
2244 		 * Check if more than one I/O is
2245 		 * required to complete the given
2246 		 * I/O operation
2247 		 */
2248 		if (ip->i_udf->udf_lbsize < PAGESIZE) {
2249 			if (cur_len >= PAGESIZE) {
2250 				multi_io = 0;
2251 				cur_len &= PAGEMASK;
2252 			} else {
2253 				multi_io = 1;
2254 				cur_len = MIN(io_len - done_len, PAGESIZE);
2255 			}
2256 		}
2257 		page_list_break(&cpp, &npp, btop(cur_len));
2258 
2259 		bp = pageio_setup(cpp, cur_len, ip->i_devvp, flags);
2260 		ASSERT(bp != NULL);
2261 
2262 		bp->b_edev = ip->i_dev;
2263 		bp->b_dev = cmpdev(ip->i_dev);
2264 		bp->b_blkno = bn;
2265 		bp->b_un.b_addr = (caddr_t)0;
2266 		bp->b_file = vp;
2267 		bp->b_offset = (offset_t)(io_off + done_len);
2268 
2269 /*
2270  *		ub.ub_pageios.value.ul++;
2271  */
2272 		if (multi_io == 0) {
2273 			(void) bdev_strategy(bp);
2274 		} else {
2275 			error = ud_multi_strat(ip, cpp, bp,
2276 			    (u_offset_t)(io_off + done_len));
2277 			if (error != 0) {
2278 				pageio_done(bp);
2279 				break;
2280 			}
2281 		}
2282 		if (flags & B_READ) {
2283 			ud_pageio_reads++;
2284 		} else {
2285 			ud_pageio_writes++;
2286 		}
2287 
2288 		/*
2289 		 * If the request is not B_ASYNC, wait for i/o to complete
2290 		 * and re-assemble the page list to return to the caller.
2291 		 * If it is B_ASYNC we leave the page list in pieces and
2292 		 * cleanup() will dispose of them.
2293 		 */
2294 		if ((flags & B_ASYNC) == 0) {
2295 			error = biowait(bp);
2296 			pageio_done(bp);
2297 			if (error) {
2298 				break;
2299 			}
2300 			page_list_concat(&opp, &cpp);
2301 		}
2302 		cpp = npp;
2303 		npp = NULL;
2304 		done_len += cur_len;
2305 	}
2306 
2307 	ASSERT(error || (cpp == NULL && npp == NULL && done_len == io_len));
2308 	if (error) {
2309 		if (flags & B_ASYNC) {
2310 			/* Cleanup unprocessed parts of list */
2311 			page_list_concat(&cpp, &npp);
2312 			if (flags & B_READ) {
2313 				pvn_read_done(cpp, B_ERROR);
2314 			} else {
2315 				pvn_write_done(cpp, B_ERROR);
2316 			}
2317 		} else {
2318 			/* Re-assemble list and let caller clean up */
2319 			page_list_concat(&opp, &cpp);
2320 			page_list_concat(&opp, &npp);
2321 		}
2322 	}
2323 
2324 #ifdef	__lock_lint
2325 	rw_exit(&ip->i_contents);
2326 #else
2327 	if (dolock) {
2328 		rw_exit(&ip->i_contents);
2329 	}
2330 #endif
2331 	return (error);
2332 }
2333 
2334 
2335 
2336 
2337 /* -------------------- local functions --------------------------- */
2338 
2339 
2340 
2341 int32_t
ud_rdwri(enum uio_rw rw,int32_t ioflag,struct ud_inode * ip,caddr_t base,int32_t len,offset_t offset,enum uio_seg seg,int32_t * aresid,struct cred * cr)2342 ud_rdwri(enum uio_rw rw, int32_t ioflag, struct ud_inode *ip, caddr_t base,
2343     int32_t len, offset_t offset, enum uio_seg seg, int32_t *aresid,
2344     struct cred *cr)
2345 {
2346 	int32_t error;
2347 	struct uio auio;
2348 	struct iovec aiov;
2349 
2350 	ud_printf("ud_rdwri\n");
2351 
2352 	bzero((caddr_t)&auio, sizeof (uio_t));
2353 	bzero((caddr_t)&aiov, sizeof (iovec_t));
2354 
2355 	aiov.iov_base = base;
2356 	aiov.iov_len = len;
2357 	auio.uio_iov = &aiov;
2358 	auio.uio_iovcnt = 1;
2359 	auio.uio_loffset = offset;
2360 	auio.uio_segflg = (int16_t)seg;
2361 	auio.uio_resid = len;
2362 
2363 	if (rw == UIO_WRITE) {
2364 		auio.uio_fmode = FWRITE;
2365 		auio.uio_extflg = UIO_COPY_DEFAULT;
2366 		auio.uio_llimit = curproc->p_fsz_ctl;
2367 		error = ud_wrip(ip, &auio, ioflag, cr);
2368 	} else {
2369 		auio.uio_fmode = FREAD;
2370 		auio.uio_extflg = UIO_COPY_CACHED;
2371 		auio.uio_llimit = MAXOFFSET_T;
2372 		error = ud_rdip(ip, &auio, ioflag, cr);
2373 	}
2374 
2375 	if (aresid) {
2376 		*aresid = auio.uio_resid;
2377 	} else if (auio.uio_resid) {
2378 		error = EIO;
2379 	}
2380 	return (error);
2381 }
2382 
2383 /*
2384  * Free behind hacks.  The pager is busted.
2385  * XXX - need to pass the information down to writedone() in a flag like B_SEQ
2386  * or B_FREE_IF_TIGHT_ON_MEMORY.
2387  */
2388 int32_t ud_freebehind = 1;
2389 int32_t ud_smallfile = 32 * 1024;
2390 
2391 /* ARGSUSED */
2392 int32_t
ud_getpage_miss(struct vnode * vp,u_offset_t off,size_t len,struct seg * seg,caddr_t addr,page_t * pl[],size_t plsz,enum seg_rw rw,int32_t seq)2393 ud_getpage_miss(struct vnode *vp, u_offset_t off, size_t len, struct seg *seg,
2394     caddr_t addr, page_t *pl[], size_t plsz, enum seg_rw rw, int32_t seq)
2395 {
2396 	struct ud_inode *ip = VTOI(vp);
2397 	int32_t err = 0;
2398 	size_t io_len;
2399 	u_offset_t io_off;
2400 	u_offset_t pgoff;
2401 	page_t *pp;
2402 
2403 	pl[0] = NULL;
2404 
2405 	/*
2406 	 * Figure out whether the page can be created, or must be
2407 	 * read from the disk
2408 	 */
2409 	if (rw == S_CREATE) {
2410 		if ((pp = page_create_va(vp, off,
2411 		    PAGESIZE, PG_WAIT, seg, addr)) == NULL) {
2412 			cmn_err(CE_WARN, "ud_getpage_miss: page_create");
2413 			return (EINVAL);
2414 		}
2415 		io_len = PAGESIZE;
2416 	} else {
2417 		pp = pvn_read_kluster(vp, off, seg, addr, &io_off,
2418 		    &io_len, off, PAGESIZE, 0);
2419 
2420 		/*
2421 		 * Some other thread has entered the page.
2422 		 * ud_getpage will retry page_lookup.
2423 		 */
2424 		if (pp == NULL) {
2425 			return (0);
2426 		}
2427 
2428 		/*
2429 		 * Fill the page with as much data as we can from the file.
2430 		 */
2431 		err = ud_page_fill(ip, pp, off, B_READ, &pgoff);
2432 		if (err) {
2433 			pvn_read_done(pp, B_ERROR);
2434 			return (err);
2435 		}
2436 
2437 		/*
2438 		 * XXX ??? ufs has io_len instead of pgoff below
2439 		 */
2440 		ip->i_nextrio = off + ((pgoff + PAGESIZE - 1) & PAGEMASK);
2441 
2442 		/*
2443 		 * If the file access is sequential, initiate read ahead
2444 		 * of the next cluster.
2445 		 */
2446 		if (seq && ip->i_nextrio < ip->i_size) {
2447 			ud_getpage_ra(vp, off, seg, addr);
2448 		}
2449 	}
2450 
2451 outmiss:
2452 	pvn_plist_init(pp, pl, plsz, (offset_t)off, io_len, rw);
2453 	return (err);
2454 }
2455 
2456 /* ARGSUSED */
2457 void
ud_getpage_ra(struct vnode * vp,u_offset_t off,struct seg * seg,caddr_t addr)2458 ud_getpage_ra(struct vnode *vp, u_offset_t off, struct seg *seg, caddr_t addr)
2459 {
2460 	page_t *pp;
2461 	size_t io_len;
2462 	struct ud_inode *ip = VTOI(vp);
2463 	u_offset_t io_off = ip->i_nextrio, pgoff;
2464 	caddr_t addr2 = addr + (io_off - off);
2465 	daddr_t bn;
2466 	int32_t contig = 0;
2467 
2468 	/*
2469 	 * Is this test needed?
2470 	 */
2471 
2472 	if (addr2 >= seg->s_base + seg->s_size) {
2473 		return;
2474 	}
2475 
2476 	contig = 0;
2477 	if (ud_bmap_read(ip, io_off, &bn, &contig) != 0 || bn == UDF_HOLE) {
2478 		return;
2479 	}
2480 
2481 	pp = pvn_read_kluster(vp, io_off, seg, addr2,
2482 	    &io_off, &io_len, io_off, PAGESIZE, 1);
2483 
2484 	/*
2485 	 * Some other thread has entered the page.
2486 	 * So no read head done here (ie we will have to and wait
2487 	 * for the read when needed).
2488 	 */
2489 
2490 	if (pp == NULL) {
2491 		return;
2492 	}
2493 
2494 	(void) ud_page_fill(ip, pp, io_off, (B_READ|B_ASYNC), &pgoff);
2495 	ip->i_nextrio =  io_off + ((pgoff + PAGESIZE - 1) & PAGEMASK);
2496 }
2497 
2498 int
ud_page_fill(struct ud_inode * ip,page_t * pp,u_offset_t off,uint32_t bflgs,u_offset_t * pg_off)2499 ud_page_fill(struct ud_inode *ip, page_t *pp, u_offset_t off, uint32_t bflgs,
2500     u_offset_t *pg_off)
2501 {
2502 	daddr_t bn;
2503 	struct buf *bp;
2504 	caddr_t kaddr, caddr;
2505 	int32_t error = 0, contig = 0, multi_io = 0;
2506 	int32_t lbsize = ip->i_udf->udf_lbsize;
2507 	int32_t lbmask = ip->i_udf->udf_lbmask;
2508 	uint64_t isize;
2509 
2510 	isize = (ip->i_size + lbmask) & (~lbmask);
2511 	if (ip->i_desc_type == ICB_FLAG_ONE_AD) {
2512 
2513 		/*
2514 		 * Embedded file read file_entry
2515 		 * from buffer cache and copy the required
2516 		 * portions
2517 		 */
2518 		bp = ud_bread(ip->i_dev,
2519 		    ip->i_icb_lbano << ip->i_udf->udf_l2d_shift, lbsize);
2520 		if ((bp->b_error == 0) &&
2521 		    (bp->b_resid == 0)) {
2522 
2523 			caddr = bp->b_un.b_addr + ip->i_data_off;
2524 
2525 			/*
2526 			 * mapin to kvm
2527 			 */
2528 			kaddr = (caddr_t)ppmapin(pp,
2529 			    PROT_READ | PROT_WRITE, (caddr_t)-1);
2530 			(void) kcopy(caddr, kaddr, ip->i_size);
2531 
2532 			/*
2533 			 * mapout of kvm
2534 			 */
2535 			ppmapout(kaddr);
2536 		}
2537 		brelse(bp);
2538 		contig = ip->i_size;
2539 	} else {
2540 
2541 		/*
2542 		 * Get the continuous size and block number
2543 		 * at offset "off"
2544 		 */
2545 		if (error = ud_bmap_read(ip, off, &bn, &contig))
2546 			goto out;
2547 		contig = MIN(contig, PAGESIZE);
2548 		contig = (contig + lbmask) & (~lbmask);
2549 
2550 		/*
2551 		 * Zero part of the page which we are not
2552 		 * going to read from the disk.
2553 		 */
2554 
2555 		if (bn == UDF_HOLE) {
2556 
2557 			/*
2558 			 * This is a HOLE. Just zero out
2559 			 * the page
2560 			 */
2561 			if (((off + contig) == isize) ||
2562 			    (contig == PAGESIZE)) {
2563 				pagezero(pp->p_prev, 0, PAGESIZE);
2564 				goto out;
2565 			}
2566 		}
2567 
2568 		if (contig < PAGESIZE) {
2569 			uint64_t count;
2570 
2571 			count = isize - off;
2572 			if (contig != count) {
2573 				multi_io = 1;
2574 				contig = (int32_t)(MIN(count, PAGESIZE));
2575 			} else {
2576 				pagezero(pp->p_prev, contig, PAGESIZE - contig);
2577 			}
2578 		}
2579 
2580 		/*
2581 		 * Get a bp and initialize it
2582 		 */
2583 		bp = pageio_setup(pp, contig, ip->i_devvp, bflgs);
2584 		ASSERT(bp != NULL);
2585 
2586 		bp->b_edev = ip->i_dev;
2587 		bp->b_dev = cmpdev(ip->i_dev);
2588 		bp->b_blkno = bn;
2589 		bp->b_un.b_addr = 0;
2590 		bp->b_file = ip->i_vnode;
2591 
2592 		/*
2593 		 * Start I/O
2594 		 */
2595 		if (multi_io == 0) {
2596 
2597 			/*
2598 			 * Single I/O is sufficient for this page
2599 			 */
2600 			(void) bdev_strategy(bp);
2601 		} else {
2602 
2603 			/*
2604 			 * We need to do the I/O in
2605 			 * piece's
2606 			 */
2607 			error = ud_multi_strat(ip, pp, bp, off);
2608 			if (error != 0) {
2609 				goto out;
2610 			}
2611 		}
2612 		if ((bflgs & B_ASYNC) == 0) {
2613 
2614 			/*
2615 			 * Wait for i/o to complete.
2616 			 */
2617 
2618 			error = biowait(bp);
2619 			pageio_done(bp);
2620 			if (error) {
2621 				goto out;
2622 			}
2623 		}
2624 	}
2625 	if ((off + contig) >= ip->i_size) {
2626 		contig = ip->i_size - off;
2627 	}
2628 
2629 out:
2630 	*pg_off = contig;
2631 	return (error);
2632 }
2633 
2634 int32_t
ud_putpages(struct vnode * vp,offset_t off,size_t len,int32_t flags,struct cred * cr)2635 ud_putpages(struct vnode *vp, offset_t off, size_t len, int32_t flags,
2636     struct cred *cr)
2637 {
2638 	struct ud_inode *ip;
2639 	page_t *pp;
2640 	u_offset_t io_off;
2641 	size_t io_len;
2642 	u_offset_t eoff;
2643 	int32_t err = 0;
2644 	int32_t dolock;
2645 
2646 	ud_printf("ud_putpages\n");
2647 
2648 	if (vp->v_count == 0) {
2649 		cmn_err(CE_WARN, "ud_putpages: bad v_count");
2650 		return (EINVAL);
2651 	}
2652 
2653 	ip = VTOI(vp);
2654 
2655 	/*
2656 	 * Acquire the readers/write inode lock before locking
2657 	 * any pages in this inode.
2658 	 * The inode lock is held during i/o.
2659 	 */
2660 	if (len == 0) {
2661 		mutex_enter(&ip->i_tlock);
2662 		ip->i_delayoff = ip->i_delaylen = 0;
2663 		mutex_exit(&ip->i_tlock);
2664 	}
2665 #ifdef	__lock_lint
2666 	rw_enter(&ip->i_contents, RW_READER);
2667 #else
2668 	dolock = (rw_owner(&ip->i_contents) != curthread);
2669 	if (dolock) {
2670 		rw_enter(&ip->i_contents, RW_READER);
2671 	}
2672 #endif
2673 
2674 	if (!vn_has_cached_data(vp)) {
2675 #ifdef	__lock_lint
2676 		rw_exit(&ip->i_contents);
2677 #else
2678 		if (dolock) {
2679 			rw_exit(&ip->i_contents);
2680 		}
2681 #endif
2682 		return (0);
2683 	}
2684 
2685 	if (len == 0) {
2686 		/*
2687 		 * Search the entire vp list for pages >= off.
2688 		 */
2689 		err = pvn_vplist_dirty(vp, (u_offset_t)off, ud_putapage,
2690 		    flags, cr);
2691 	} else {
2692 		/*
2693 		 * Loop over all offsets in the range looking for
2694 		 * pages to deal with.
2695 		 */
2696 		if ((eoff = blkroundup(ip->i_udf, ip->i_size)) != 0) {
2697 			eoff = MIN(off + len, eoff);
2698 		} else {
2699 			eoff = off + len;
2700 		}
2701 
2702 		for (io_off = off; io_off < eoff; io_off += io_len) {
2703 			/*
2704 			 * If we are not invalidating, synchronously
2705 			 * freeing or writing pages, use the routine
2706 			 * page_lookup_nowait() to prevent reclaiming
2707 			 * them from the free list.
2708 			 */
2709 			if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
2710 				pp = page_lookup(vp, io_off,
2711 				    (flags & (B_INVAL | B_FREE)) ?
2712 				    SE_EXCL : SE_SHARED);
2713 			} else {
2714 				pp = page_lookup_nowait(vp, io_off,
2715 				    (flags & B_FREE) ? SE_EXCL : SE_SHARED);
2716 			}
2717 
2718 			if (pp == NULL || pvn_getdirty(pp, flags) == 0) {
2719 				io_len = PAGESIZE;
2720 			} else {
2721 
2722 				err = ud_putapage(vp, pp,
2723 				    &io_off, &io_len, flags, cr);
2724 				if (err != 0) {
2725 					break;
2726 				}
2727 				/*
2728 				 * "io_off" and "io_len" are returned as
2729 				 * the range of pages we actually wrote.
2730 				 * This allows us to skip ahead more quickly
2731 				 * since several pages may've been dealt
2732 				 * with by this iteration of the loop.
2733 				 */
2734 			}
2735 		}
2736 	}
2737 	if (err == 0 && off == 0 && (len == 0 || len >= ip->i_size)) {
2738 		/*
2739 		 * We have just sync'ed back all the pages on
2740 		 * the inode, turn off the IMODTIME flag.
2741 		 */
2742 		mutex_enter(&ip->i_tlock);
2743 		ip->i_flag &= ~IMODTIME;
2744 		mutex_exit(&ip->i_tlock);
2745 	}
2746 #ifdef	__lock_lint
2747 	rw_exit(&ip->i_contents);
2748 #else
2749 	if (dolock) {
2750 		rw_exit(&ip->i_contents);
2751 	}
2752 #endif
2753 	return (err);
2754 }
2755 
2756 /* ARGSUSED */
2757 int32_t
ud_putapage(struct vnode * vp,page_t * pp,u_offset_t * offp,size_t * lenp,int32_t flags,struct cred * cr)2758 ud_putapage(struct vnode *vp, page_t *pp, u_offset_t *offp,
2759     size_t *lenp, int32_t flags, struct cred *cr)
2760 {
2761 	daddr_t bn;
2762 	size_t io_len;
2763 	struct ud_inode *ip;
2764 	int32_t error = 0, contig, multi_io = 0;
2765 	struct udf_vfs *udf_vfsp;
2766 	u_offset_t off, io_off;
2767 	caddr_t kaddr, caddr;
2768 	struct buf *bp = NULL;
2769 	int32_t lbmask;
2770 	uint64_t isize;
2771 	uint16_t crc_len;
2772 	struct file_entry *fe;
2773 
2774 	ud_printf("ud_putapage\n");
2775 
2776 	ip = VTOI(vp);
2777 	ASSERT(ip);
2778 	ASSERT(RW_LOCK_HELD(&ip->i_contents));
2779 	lbmask = ip->i_udf->udf_lbmask;
2780 	isize = (ip->i_size + lbmask) & (~lbmask);
2781 
2782 	udf_vfsp = ip->i_udf;
2783 	ASSERT(udf_vfsp->udf_flags & UDF_FL_RW);
2784 
2785 	/*
2786 	 * If the modified time on the inode has not already been
2787 	 * set elsewhere (e.g. for write/setattr) we set the time now.
2788 	 * This gives us approximate modified times for mmap'ed files
2789 	 * which are modified via stores in the user address space.
2790 	 */
2791 	if (((ip->i_flag & IMODTIME) == 0) || (flags & B_FORCE)) {
2792 		mutex_enter(&ip->i_tlock);
2793 		ip->i_flag |= IUPD;
2794 		ITIMES_NOLOCK(ip);
2795 		mutex_exit(&ip->i_tlock);
2796 	}
2797 
2798 
2799 	/*
2800 	 * Align the request to a block boundry (for old file systems),
2801 	 * and go ask bmap() how contiguous things are for this file.
2802 	 */
2803 	off = pp->p_offset & ~(offset_t)lbmask;
2804 				/* block align it */
2805 
2806 
2807 	if (ip->i_desc_type == ICB_FLAG_ONE_AD) {
2808 		ASSERT(ip->i_size <= ip->i_max_emb);
2809 
2810 		pp = pvn_write_kluster(vp, pp, &io_off,
2811 		    &io_len, off, PAGESIZE, flags);
2812 		if (io_len == 0) {
2813 			io_len = PAGESIZE;
2814 		}
2815 
2816 		bp = ud_bread(ip->i_dev,
2817 		    ip->i_icb_lbano << udf_vfsp->udf_l2d_shift,
2818 		    udf_vfsp->udf_lbsize);
2819 		fe = (struct file_entry *)bp->b_un.b_addr;
2820 		if ((bp->b_flags & B_ERROR) ||
2821 		    (ud_verify_tag_and_desc(&fe->fe_tag, UD_FILE_ENTRY,
2822 		    ip->i_icb_block,
2823 		    1, udf_vfsp->udf_lbsize) != 0)) {
2824 			if (pp != NULL)
2825 				pvn_write_done(pp, B_ERROR | B_WRITE | flags);
2826 			if (bp->b_flags & B_ERROR) {
2827 				error = EIO;
2828 			} else {
2829 				error = EINVAL;
2830 			}
2831 			brelse(bp);
2832 			return (error);
2833 		}
2834 		if ((bp->b_error == 0) &&
2835 		    (bp->b_resid == 0)) {
2836 
2837 			caddr = bp->b_un.b_addr + ip->i_data_off;
2838 			kaddr = (caddr_t)ppmapin(pp,
2839 			    PROT_READ | PROT_WRITE, (caddr_t)-1);
2840 			(void) kcopy(kaddr, caddr, ip->i_size);
2841 			ppmapout(kaddr);
2842 		}
2843 		crc_len = offsetof(struct file_entry, fe_spec) +
2844 		    SWAP_32(fe->fe_len_ear);
2845 		crc_len += ip->i_size;
2846 		ud_make_tag(ip->i_udf, &fe->fe_tag,
2847 		    UD_FILE_ENTRY, ip->i_icb_block, crc_len);
2848 
2849 		bwrite(bp);
2850 
2851 		if (flags & B_ASYNC) {
2852 			pvn_write_done(pp, flags);
2853 		}
2854 		contig = ip->i_size;
2855 	} else {
2856 
2857 		if (error = ud_bmap_read(ip, off, &bn, &contig)) {
2858 			goto out;
2859 		}
2860 		contig = MIN(contig, PAGESIZE);
2861 		contig = (contig + lbmask) & (~lbmask);
2862 
2863 		if (contig < PAGESIZE) {
2864 			uint64_t count;
2865 
2866 			count = isize - off;
2867 			if (contig != count) {
2868 				multi_io = 1;
2869 				contig = (int32_t)(MIN(count, PAGESIZE));
2870 			}
2871 		}
2872 
2873 		if ((off + contig) > isize) {
2874 			contig = isize - off;
2875 		}
2876 
2877 		if (contig > PAGESIZE) {
2878 			if (contig & PAGEOFFSET) {
2879 				contig &= PAGEMASK;
2880 			}
2881 		}
2882 
2883 		pp = pvn_write_kluster(vp, pp, &io_off,
2884 		    &io_len, off, contig, flags);
2885 		if (io_len == 0) {
2886 			io_len = PAGESIZE;
2887 		}
2888 
2889 		bp = pageio_setup(pp, contig, ip->i_devvp, B_WRITE | flags);
2890 		ASSERT(bp != NULL);
2891 
2892 		bp->b_edev = ip->i_dev;
2893 		bp->b_dev = cmpdev(ip->i_dev);
2894 		bp->b_blkno = bn;
2895 		bp->b_un.b_addr = 0;
2896 		bp->b_file = vp;
2897 		bp->b_offset = (offset_t)off;
2898 
2899 
2900 		/*
2901 		 * write throttle
2902 		 */
2903 		ASSERT(bp->b_iodone == NULL);
2904 		bp->b_iodone = ud_iodone;
2905 		mutex_enter(&ip->i_tlock);
2906 		ip->i_writes += bp->b_bcount;
2907 		mutex_exit(&ip->i_tlock);
2908 
2909 		if (multi_io == 0) {
2910 
2911 			(void) bdev_strategy(bp);
2912 		} else {
2913 			error = ud_multi_strat(ip, pp, bp, off);
2914 			if (error != 0) {
2915 				goto out;
2916 			}
2917 		}
2918 
2919 		if ((flags & B_ASYNC) == 0) {
2920 			/*
2921 			 * Wait for i/o to complete.
2922 			 */
2923 			error = biowait(bp);
2924 			pageio_done(bp);
2925 		}
2926 	}
2927 
2928 	if ((flags & B_ASYNC) == 0) {
2929 		pvn_write_done(pp, ((error) ? B_ERROR : 0) | B_WRITE | flags);
2930 	}
2931 
2932 	pp = NULL;
2933 
2934 out:
2935 	if (error != 0 && pp != NULL) {
2936 		pvn_write_done(pp, B_ERROR | B_WRITE | flags);
2937 	}
2938 
2939 	if (offp) {
2940 		*offp = io_off;
2941 	}
2942 	if (lenp) {
2943 		*lenp = io_len;
2944 	}
2945 
2946 	return (error);
2947 }
2948 
2949 
2950 int32_t
ud_iodone(struct buf * bp)2951 ud_iodone(struct buf *bp)
2952 {
2953 	struct ud_inode *ip;
2954 
2955 	ASSERT((bp->b_pages->p_vnode != NULL) && !(bp->b_flags & B_READ));
2956 
2957 	bp->b_iodone = NULL;
2958 
2959 	ip = VTOI(bp->b_pages->p_vnode);
2960 
2961 	mutex_enter(&ip->i_tlock);
2962 	if (ip->i_writes >= ud_LW) {
2963 		if ((ip->i_writes -= bp->b_bcount) <= ud_LW) {
2964 			if (ud_WRITES) {
2965 				cv_broadcast(&ip->i_wrcv); /* wake all up */
2966 			}
2967 		}
2968 	} else {
2969 		ip->i_writes -= bp->b_bcount;
2970 	}
2971 	mutex_exit(&ip->i_tlock);
2972 	iodone(bp);
2973 	return (0);
2974 }
2975 
2976 /* ARGSUSED3 */
2977 int32_t
ud_rdip(struct ud_inode * ip,struct uio * uio,int32_t ioflag,cred_t * cr)2978 ud_rdip(struct ud_inode *ip, struct uio *uio, int32_t ioflag, cred_t *cr)
2979 {
2980 	struct vnode *vp;
2981 	struct udf_vfs *udf_vfsp;
2982 	krw_t rwtype;
2983 	caddr_t base;
2984 	uint32_t flags;
2985 	int32_t error, n, on, mapon, dofree;
2986 	u_offset_t off;
2987 	long oresid = uio->uio_resid;
2988 
2989 	ASSERT(RW_LOCK_HELD(&ip->i_contents));
2990 	if ((ip->i_type != VREG) &&
2991 	    (ip->i_type != VDIR) &&
2992 	    (ip->i_type != VLNK)) {
2993 		return (EIO);
2994 	}
2995 
2996 	if (uio->uio_loffset > MAXOFFSET_T) {
2997 		return (0);
2998 	}
2999 
3000 	if ((uio->uio_loffset < (offset_t)0) ||
3001 	    ((uio->uio_loffset + uio->uio_resid) < 0)) {
3002 		return (EINVAL);
3003 	}
3004 	if (uio->uio_resid == 0) {
3005 		return (0);
3006 	}
3007 
3008 	vp = ITOV(ip);
3009 	udf_vfsp = ip->i_udf;
3010 	mutex_enter(&ip->i_tlock);
3011 	ip->i_flag |= IACC;
3012 	mutex_exit(&ip->i_tlock);
3013 
3014 	rwtype = (rw_write_held(&ip->i_contents)?RW_WRITER:RW_READER);
3015 
3016 	do {
3017 		offset_t diff;
3018 		u_offset_t uoff = uio->uio_loffset;
3019 		off = uoff & (offset_t)MAXBMASK;
3020 		mapon = (int)(uoff & (offset_t)MAXBOFFSET);
3021 		on = (int)blkoff(udf_vfsp, uoff);
3022 		n = (int)MIN(udf_vfsp->udf_lbsize - on, uio->uio_resid);
3023 
3024 		diff = ip->i_size - uoff;
3025 
3026 		if (diff <= (offset_t)0) {
3027 			error = 0;
3028 			goto out;
3029 		}
3030 		if (diff < (offset_t)n) {
3031 			n = (int)diff;
3032 		}
3033 		dofree = ud_freebehind &&
3034 		    ip->i_nextr == (off & PAGEMASK) &&
3035 		    off > ud_smallfile;
3036 
3037 #ifndef	__lock_lint
3038 		if (rwtype == RW_READER) {
3039 			rw_exit(&ip->i_contents);
3040 		}
3041 #endif
3042 
3043 		base = segmap_getmapflt(segkmap, vp, (off + mapon),
3044 		    (uint32_t)n, 1, S_READ);
3045 		error = uiomove(base + mapon, (long)n, UIO_READ, uio);
3046 
3047 		flags = 0;
3048 		if (!error) {
3049 			/*
3050 			 * If read a whole block, or read to eof,
3051 			 * won't need this buffer again soon.
3052 			 */
3053 			if (n + on == MAXBSIZE && ud_freebehind && dofree &&
3054 			    freemem < lotsfree + pages_before_pager) {
3055 				flags = SM_FREE | SM_DONTNEED |SM_ASYNC;
3056 			}
3057 			/*
3058 			 * In POSIX SYNC (FSYNC and FDSYNC) read mode,
3059 			 * we want to make sure that the page which has
3060 			 * been read, is written on disk if it is dirty.
3061 			 * And corresponding indirect blocks should also
3062 			 * be flushed out.
3063 			 */
3064 			if ((ioflag & FRSYNC) && (ioflag & (FSYNC|FDSYNC))) {
3065 				flags &= ~SM_ASYNC;
3066 				flags |= SM_WRITE;
3067 			}
3068 			error = segmap_release(segkmap, base, flags);
3069 		} else    {
3070 			(void) segmap_release(segkmap, base, flags);
3071 		}
3072 
3073 #ifndef __lock_lint
3074 		if (rwtype == RW_READER) {
3075 			rw_enter(&ip->i_contents, rwtype);
3076 		}
3077 #endif
3078 	} while (error == 0 && uio->uio_resid > 0 && n != 0);
3079 out:
3080 	/*
3081 	 * Inode is updated according to this table if FRSYNC is set.
3082 	 *
3083 	 *	FSYNC	FDSYNC(posix.4)
3084 	 *	--------------------------
3085 	 *	always	IATTCHG|IBDWRITE
3086 	 */
3087 	if (ioflag & FRSYNC) {
3088 		if ((ioflag & FSYNC) ||
3089 		    ((ioflag & FDSYNC) &&
3090 		    (ip->i_flag & (IATTCHG|IBDWRITE)))) {
3091 		rw_exit(&ip->i_contents);
3092 		rw_enter(&ip->i_contents, RW_WRITER);
3093 		ud_iupdat(ip, 1);
3094 		}
3095 	}
3096 	/*
3097 	 * If we've already done a partial read, terminate
3098 	 * the read but return no error.
3099 	 */
3100 	if (oresid != uio->uio_resid) {
3101 		error = 0;
3102 	}
3103 	ITIMES(ip);
3104 
3105 	return (error);
3106 }
3107 
3108 int32_t
ud_wrip(struct ud_inode * ip,struct uio * uio,int ioflag,struct cred * cr)3109 ud_wrip(struct ud_inode *ip, struct uio *uio, int ioflag, struct cred *cr)
3110 {
3111 	caddr_t base;
3112 	struct vnode *vp;
3113 	struct udf_vfs *udf_vfsp;
3114 	uint32_t flags;
3115 	int32_t error = 0, iupdat_flag, n, on, mapon, i_size_changed = 0;
3116 	int32_t pagecreate, newpage;
3117 	uint64_t old_i_size;
3118 	u_offset_t off;
3119 	long start_resid = uio->uio_resid, premove_resid;
3120 	rlim64_t limit = uio->uio_limit;
3121 
3122 
3123 	ASSERT(RW_WRITE_HELD(&ip->i_contents));
3124 	if ((ip->i_type != VREG) &&
3125 	    (ip->i_type != VDIR) &&
3126 	    (ip->i_type != VLNK)) {
3127 		return (EIO);
3128 	}
3129 
3130 	if (uio->uio_loffset >= MAXOFFSET_T) {
3131 		return (EFBIG);
3132 	}
3133 	/*
3134 	 * see udf_l_pathconf
3135 	 */
3136 	if (limit > (((uint64_t)1 << 40) - 1)) {
3137 		limit = ((uint64_t)1 << 40) - 1;
3138 	}
3139 	if (uio->uio_loffset >= limit) {
3140 		proc_t *p = ttoproc(curthread);
3141 
3142 		mutex_enter(&p->p_lock);
3143 		(void) rctl_action(rctlproc_legacy[RLIMIT_FSIZE], p->p_rctls,
3144 		    p, RCA_UNSAFE_SIGINFO);
3145 		mutex_exit(&p->p_lock);
3146 		return (EFBIG);
3147 	}
3148 	if ((uio->uio_loffset < (offset_t)0) ||
3149 	    ((uio->uio_loffset + uio->uio_resid) < 0)) {
3150 		return (EINVAL);
3151 	}
3152 	if (uio->uio_resid == 0) {
3153 		return (0);
3154 	}
3155 
3156 	mutex_enter(&ip->i_tlock);
3157 	ip->i_flag |= INOACC;
3158 
3159 	if (ioflag & (FSYNC | FDSYNC)) {
3160 		ip->i_flag |= ISYNC;
3161 		iupdat_flag = 1;
3162 	}
3163 	mutex_exit(&ip->i_tlock);
3164 
3165 	udf_vfsp = ip->i_udf;
3166 	vp = ITOV(ip);
3167 
3168 	do {
3169 		u_offset_t uoff = uio->uio_loffset;
3170 		off = uoff & (offset_t)MAXBMASK;
3171 		mapon = (int)(uoff & (offset_t)MAXBOFFSET);
3172 		on = (int)blkoff(udf_vfsp, uoff);
3173 		n = (int)MIN(udf_vfsp->udf_lbsize - on, uio->uio_resid);
3174 
3175 		if (ip->i_type == VREG && uoff + n >= limit) {
3176 			if (uoff >= limit) {
3177 				error = EFBIG;
3178 				goto out;
3179 			}
3180 			n = (int)(limit - (rlim64_t)uoff);
3181 		}
3182 		if (uoff + n > ip->i_size) {
3183 			/*
3184 			 * We are extending the length of the file.
3185 			 * bmap is used so that we are sure that
3186 			 * if we need to allocate new blocks, that it
3187 			 * is done here before we up the file size.
3188 			 */
3189 			error = ud_bmap_write(ip, uoff,
3190 			    (int)(on + n), mapon == 0, cr);
3191 			if (error) {
3192 				break;
3193 			}
3194 			i_size_changed = 1;
3195 			old_i_size = ip->i_size;
3196 			ip->i_size = uoff + n;
3197 			/*
3198 			 * If we are writing from the beginning of
3199 			 * the mapping, we can just create the
3200 			 * pages without having to read them.
3201 			 */
3202 			pagecreate = (mapon == 0);
3203 		} else if (n == MAXBSIZE) {
3204 			/*
3205 			 * Going to do a whole mappings worth,
3206 			 * so we can just create the pages w/o
3207 			 * having to read them in.  But before
3208 			 * we do that, we need to make sure any
3209 			 * needed blocks are allocated first.
3210 			 */
3211 			error = ud_bmap_write(ip, uoff,
3212 			    (int)(on + n), 1, cr);
3213 			if (error) {
3214 				break;