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 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2017 by Delphix. All rights reserved.
24 */
25
26 #include <sys/types.h>
27 #include <sys/t_lock.h>
28 #include <sys/param.h>
29 #include <sys/time.h>
30 #include <sys/systm.h>
31 #include <sys/sysmacros.h>
32 #include <sys/resource.h>
33 #include <sys/signal.h>
34 #include <sys/cred.h>
35 #include <sys/user.h>
36 #include <sys/buf.h>
37 #include <sys/vfs.h>
38 #include <sys/stat.h>
39 #include <sys/vnode.h>
40 #include <sys/mode.h>
41 #include <sys/proc.h>
42 #include <sys/disp.h>
43 #include <sys/file.h>
44 #include <sys/fcntl.h>
45 #include <sys/flock.h>
46 #include <sys/kmem.h>
47 #include <sys/uio.h>
48 #include <sys/dnlc.h>
49 #include <sys/conf.h>
50 #include <sys/errno.h>
51 #include <sys/mman.h>
52 #include <sys/fbuf.h>
53 #include <sys/pathname.h>
54 #include <sys/debug.h>
55 #include <sys/vmsystm.h>
56 #include <sys/cmn_err.h>
57 #include <sys/dirent.h>
58 #include <sys/errno.h>
59 #include <sys/modctl.h>
60 #include <sys/statvfs.h>
61 #include <sys/mount.h>
62 #include <sys/sunddi.h>
63 #include <sys/bootconf.h>
64 #include <sys/policy.h>
65
66 #include <vm/hat.h>
67 #include <vm/page.h>
68 #include <vm/pvn.h>
69 #include <vm/as.h>
70 #include <vm/seg.h>
71 #include <vm/seg_map.h>
72 #include <vm/seg_kmem.h>
73 #include <vm/seg_vn.h>
74 #include <vm/rm.h>
75 #include <vm/page.h>
76 #include <sys/swap.h>
77
78
79 #include <fs/fs_subr.h>
80
81
82 #include <sys/fs/udf_volume.h>
83 #include <sys/fs/udf_inode.h>
84
85 extern struct vnodeops *udf_vnodeops;
86
87 kmutex_t ud_sync_busy;
88 /*
89 * udf_vfs list manipulation routines
90 */
91 kmutex_t udf_vfs_mutex;
92 struct udf_vfs *udf_vfs_instances;
93 #ifndef __lint
94 _NOTE(MUTEX_PROTECTS_DATA(udf_vfs_mutex, udf_vfs_instances))
95 #endif
96
97 union ihead ud_ihead[UD_HASH_SZ];
98 kmutex_t ud_icache_lock;
99
100 #define UD_BEGIN 0x0
101 #define UD_END 0x1
102 #define UD_UNKN 0x2
103 struct ud_inode *udf_ifreeh, *udf_ifreet;
104 kmutex_t udf_ifree_lock;
105 #ifndef __lint
106 _NOTE(MUTEX_PROTECTS_DATA(udf_ifree_lock, udf_ifreeh))
107 _NOTE(MUTEX_PROTECTS_DATA(udf_ifree_lock, udf_ifreet))
108 #endif
109
110 kmutex_t ud_nino_lock;
111 int32_t ud_max_inodes = 512;
112 int32_t ud_cur_inodes = 0;
113 #ifndef __lint
114 _NOTE(MUTEX_PROTECTS_DATA(ud_nino_lock, ud_cur_inodes))
115 #endif
116
117 uid_t ud_default_uid = 0;
118 gid_t ud_default_gid = 3;
119
120 int32_t ud_updat_ext4(struct ud_inode *, struct file_entry *);
121 int32_t ud_updat_ext4096(struct ud_inode *, struct file_entry *);
122 void ud_make_sad(struct icb_ext *, struct short_ad *, int32_t);
123 void ud_make_lad(struct icb_ext *, struct long_ad *, int32_t);
124 void ud_trunc_ext4(struct ud_inode *, u_offset_t);
125 void ud_trunc_ext4096(struct ud_inode *, u_offset_t);
126 void ud_add_to_free_list(struct ud_inode *, uint32_t);
127 void ud_remove_from_free_list(struct ud_inode *, uint32_t);
128
129
130 #ifdef DEBUG
131 struct ud_inode *
132 ud_search_icache(struct vfs *vfsp, uint16_t prn, uint32_t ploc)
133 {
134 int32_t hno;
135 union ihead *ih;
136 struct ud_inode *ip;
137 struct udf_vfs *udf_vfsp;
138 uint32_t loc, dummy;
139
140 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data;
141 loc = ud_xlate_to_daddr(udf_vfsp, prn, ploc, 1, &dummy);
142
143 mutex_enter(&ud_icache_lock);
144 hno = UD_INOHASH(vfsp->vfs_dev, loc);
145 ih = &ud_ihead[hno];
146 for (ip = ih->ih_chain[0];
147 ip != (struct ud_inode *)ih;
148 ip = ip->i_forw) {
149 if ((prn == ip->i_icb_prn) && (ploc == ip->i_icb_block) &&
150 (vfsp->vfs_dev == ip->i_dev)) {
151 mutex_exit(&ud_icache_lock);
152 return (ip);
153 }
154 }
155 mutex_exit(&ud_icache_lock);
156 return (0);
157 }
158 #endif
159
160 /* ARGSUSED */
161 int
162 ud_iget(struct vfs *vfsp, uint16_t prn, uint32_t ploc, struct ud_inode **ipp,
163 struct buf *pbp, struct cred *cred)
164 {
165 int32_t hno, nomem = 0, icb_tag_flags;
166 union ihead *ih;
167 struct ud_inode *ip;
168 struct vnode *vp;
169 struct buf *bp = NULL;
170 struct file_entry *fe;
171 struct udf_vfs *udf_vfsp;
172 struct ext_attr_hdr *eah;
173 struct attr_hdr *ah;
174 int32_t ea_len, ea_off;
175 daddr_t loc;
176 uint64_t offset = 0;
177 struct icb_ext *iext, *con;
178 uint32_t length, dummy;
179 int32_t ndesc, ftype;
180 uint16_t old_prn;
181 uint32_t old_block, old_lbano;
182
183 ud_printf("ud_iget\n");
184 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data;
185 old_prn = 0;
186 old_block = old_lbano = 0;
187 ftype = 0;
188 loc = ud_xlate_to_daddr(udf_vfsp, prn, ploc, 1, &dummy);
189 loop:
190 mutex_enter(&ud_icache_lock);
191 hno = UD_INOHASH(vfsp->vfs_dev, loc);
192
193 ih = &ud_ihead[hno];
194 for (ip = ih->ih_chain[0];
195 ip != (struct ud_inode *)ih;
196 ip = ip->i_forw) {
197
198 if ((prn == ip->i_icb_prn) &&
199 (ploc == ip->i_icb_block) &&
200 (vfsp->vfs_dev == ip->i_dev)) {
201
202 vp = ITOV(ip);
203 VN_HOLD(vp);
204 mutex_exit(&ud_icache_lock);
205
206 rw_enter(&ip->i_contents, RW_READER);
207 mutex_enter(&ip->i_tlock);
208 if ((ip->i_flag & IREF) == 0) {
209 mutex_enter(&udf_ifree_lock);
210 ud_remove_from_free_list(ip, UD_UNKN);
211 mutex_exit(&udf_ifree_lock);
212 }
213 ip->i_flag |= IREF;
214 mutex_exit(&ip->i_tlock);
215 rw_exit(&ip->i_contents);
216
217 *ipp = ip;
218
219 if (pbp != NULL) {
220 brelse(pbp);
221 }
222
223 return (0);
224 }
225 }
226
227 /*
228 * We don't have it in the cache
229 * Allocate a new entry
230 */
231 tryagain:
232 mutex_enter(&udf_ifree_lock);
233 mutex_enter(&ud_nino_lock);
234 if (ud_cur_inodes > ud_max_inodes) {
235 int32_t purged;
236
237 mutex_exit(&ud_nino_lock);
238 while (udf_ifreeh == NULL ||
239 vn_has_cached_data(ITOV(udf_ifreeh))) {
240 /*
241 * Try to put an inode on the freelist that's
242 * sitting in the dnlc.
243 */
244 mutex_exit(&udf_ifree_lock);
245 purged = dnlc_fs_purge1(udf_vnodeops);
246 mutex_enter(&udf_ifree_lock);
247 if (!purged) {
248 break;
249 }
250 }
251 mutex_enter(&ud_nino_lock);
252 }
253
254 /*
255 * If there's a free one available and it has no pages attached
256 * take it. If we're over the high water mark, take it even if
257 * it has attached pages. Otherwise, make a new one.
258 */
259 if (udf_ifreeh &&
260 (nomem || !vn_has_cached_data(ITOV(udf_ifreeh)) ||
261 ud_cur_inodes >= ud_max_inodes)) {
262
263 mutex_exit(&ud_nino_lock);
264 ip = udf_ifreeh;
265 vp = ITOV(ip);
266
267 ud_remove_from_free_list(ip, UD_BEGIN);
268
269 mutex_exit(&udf_ifree_lock);
270 if (ip->i_flag & IREF) {
271 cmn_err(CE_WARN, "ud_iget: bad i_flag\n");
272 mutex_exit(&ud_icache_lock);
273 if (pbp != NULL) {
274 brelse(pbp);
275 }
276 return (EINVAL);
277 }
278 rw_enter(&ip->i_contents, RW_WRITER);
279
280 /*
281 * We call udf_syncip() to synchronously destroy all pages
282 * associated with the vnode before re-using it. The pageout
283 * thread may have beat us to this page so our v_count can
284 * be > 0 at this point even though we are on the freelist.
285 */
286 mutex_enter(&ip->i_tlock);
287 ip->i_flag = (ip->i_flag & IMODTIME) | IREF;
288 mutex_exit(&ip->i_tlock);
289
290 VN_HOLD(vp);
291 if (ud_syncip(ip, B_INVAL, I_SYNC) != 0) {
292 ud_idrop(ip);
293 rw_exit(&ip->i_contents);
294 mutex_exit(&ud_icache_lock);
295 goto loop;
296 }
297
298 mutex_enter(&ip->i_tlock);
299 ip->i_flag &= ~IMODTIME;
300 mutex_exit(&ip->i_tlock);
301
302 if (ip->i_ext) {
303 kmem_free(ip->i_ext,
304 sizeof (struct icb_ext) * ip->i_ext_count);
305 ip->i_ext = 0;
306 ip->i_ext_count = ip->i_ext_used = 0;
307 }
308
309 if (ip->i_con) {
310 kmem_free(ip->i_con,
311 sizeof (struct icb_ext) * ip->i_con_count);
312 ip->i_con = 0;
313 ip->i_con_count = ip->i_con_used = ip->i_con_read = 0;
314 }
315
316 /*
317 * The pageout thread may not have had a chance to release
318 * its hold on the vnode (if it was active with this vp),
319 * but the pages should all be invalidated.
320 */
321 } else {
322 mutex_exit(&ud_nino_lock);
323 mutex_exit(&udf_ifree_lock);
324 /*
325 * Try to get memory for this inode without blocking.
326 * If we can't and there is something on the freelist,
327 * go ahead and use it, otherwise block waiting for
328 * memory holding the hash_lock. We expose a potential
329 * deadlock if all users of memory have to do a ud_iget()
330 * before releasing memory.
331 */
332 ip = (struct ud_inode *)kmem_zalloc(sizeof (struct ud_inode),
333 KM_NOSLEEP);
334 vp = vn_alloc(KM_NOSLEEP);
335 if ((ip == NULL) || (vp == NULL)) {
336 mutex_enter(&udf_ifree_lock);
337 if (udf_ifreeh) {
338 mutex_exit(&udf_ifree_lock);
339 if (ip != NULL)
340 kmem_free(ip, sizeof (struct ud_inode));
341 if (vp != NULL)
342 vn_free(vp);
343 nomem = 1;
344 goto tryagain;
345 } else {
346 mutex_exit(&udf_ifree_lock);
347 if (ip == NULL)
348 ip = (struct ud_inode *)
349 kmem_zalloc(
350 sizeof (struct ud_inode),
351 KM_SLEEP);
352 if (vp == NULL)
353 vp = vn_alloc(KM_SLEEP);
354 }
355 }
356 ip->i_vnode = vp;
357
358 ip->i_marker1 = (uint32_t)0xAAAAAAAA;
359 ip->i_marker2 = (uint32_t)0xBBBBBBBB;
360 ip->i_marker3 = (uint32_t)0xCCCCCCCC;
361
362 rw_init(&ip->i_rwlock, NULL, RW_DEFAULT, NULL);
363 rw_init(&ip->i_contents, NULL, RW_DEFAULT, NULL);
364 mutex_init(&ip->i_tlock, NULL, MUTEX_DEFAULT, NULL);
365
366 ip->i_forw = ip;
367 ip->i_back = ip;
368 vp->v_data = (caddr_t)ip;
369 vn_setops(vp, udf_vnodeops);
370 ip->i_flag = IREF;
371 cv_init(&ip->i_wrcv, NULL, CV_DRIVER, NULL);
372 mutex_enter(&ud_nino_lock);
373 ud_cur_inodes++;
374 mutex_exit(&ud_nino_lock);
375
376 rw_enter(&ip->i_contents, RW_WRITER);
377 }
378
379 if (vp->v_count < 1) {
380 cmn_err(CE_WARN, "ud_iget: v_count < 1\n");
381 mutex_exit(&ud_icache_lock);
382 rw_exit(&ip->i_contents);
383 if (pbp != NULL) {
384 brelse(pbp);
385 }
386 return (EINVAL);
387 }
388 if (vn_has_cached_data(vp)) {
389 cmn_err(CE_WARN, "ud_iget: v_pages not NULL\n");
390 mutex_exit(&ud_icache_lock);
391 rw_exit(&ip->i_contents);
392 if (pbp != NULL) {
393 brelse(pbp);
394 }
395 return (EINVAL);
396 }
397
398 /*
399 * Move the inode on the chain for its new (ino, dev) pair
400 */
401 remque(ip);
402 ip->i_forw = ip;
403 ip->i_back = ip;
404 insque(ip, ih);
405
406 ip->i_dev = vfsp->vfs_dev;
407 ip->i_udf = udf_vfsp;
408 ip->i_diroff = 0;
409 ip->i_devvp = ip->i_udf->udf_devvp;
410 ip->i_icb_prn = prn;
411 ip->i_icb_block = ploc;
412 ip->i_icb_lbano = loc;
413 ip->i_nextr = 0;
414 ip->i_seq = 0;
415 mutex_exit(&ud_icache_lock);
416
417 read_de:
418 if (pbp != NULL) {
419 /*
420 * assumption is that we will not
421 * create a 4096 file
422 */
423 bp = pbp;
424 } else {
425 bp = ud_bread(ip->i_dev,
426 ip->i_icb_lbano << udf_vfsp->udf_l2d_shift,
427 udf_vfsp->udf_lbsize);
428 }
429
430 /*
431 * Check I/O errors
432 */
433 fe = (struct file_entry *)bp->b_un.b_addr;
434 if ((bp->b_flags & B_ERROR) ||
435 (ud_verify_tag_and_desc(&fe->fe_tag, UD_FILE_ENTRY,
436 ip->i_icb_block, 1, udf_vfsp->udf_lbsize) != 0)) {
437
438 if (((bp->b_flags & B_ERROR) == 0) &&
439 (ftype == STRAT_TYPE4096)) {
440 if (ud_check_te_unrec(udf_vfsp,
441 bp->b_un.b_addr, ip->i_icb_block) == 0) {
442
443 brelse(bp);
444
445 /*
446 * restore old file entry location
447 */
448 ip->i_icb_prn = old_prn;
449 ip->i_icb_block = old_block;
450 ip->i_icb_lbano = old_lbano;
451
452 /*
453 * reread old file entry
454 */
455 bp = ud_bread(ip->i_dev,
456 old_lbano << udf_vfsp->udf_l2d_shift,
457 udf_vfsp->udf_lbsize);
458 if ((bp->b_flags & B_ERROR) == 0) {
459 fe = (struct file_entry *)
460 bp->b_un.b_addr;
461 if (ud_verify_tag_and_desc(&fe->fe_tag,
462 UD_FILE_ENTRY, ip->i_icb_block, 1,
463 udf_vfsp->udf_lbsize) == 0) {
464 goto end_4096;
465 }
466 }
467 }
468 }
469 error_ret:
470 brelse(bp);
471 /*
472 * The inode may not contain anything useful. Mark it as
473 * having an error and let anyone else who was waiting for
474 * this know there was an error. Callers waiting for
475 * access to this inode in ud_iget will find
476 * the i_icb_lbano == 0, so there won't be a match.
477 * It remains in the cache. Put it back on the freelist.
478 */
479 mutex_enter(&vp->v_lock);
480 VN_RELE_LOCKED(vp);
481 mutex_exit(&vp->v_lock);
482 ip->i_icb_lbano = 0;
483
484 /*
485 * The folowing two lines make
486 * it impossible for any one do
487 * a VN_HOLD and then a VN_RELE
488 * so avoiding a ud_iinactive
489 */
490 ip->i_icb_prn = 0xffff;
491 ip->i_icb_block = 0;
492
493 /*
494 * remove the bad inode from hash chains
495 * so that during unmount we will not
496 * go through this inode
497 */
498 mutex_enter(&ud_icache_lock);
499 remque(ip);
500 ip->i_forw = ip;
501 ip->i_back = ip;
502 mutex_exit(&ud_icache_lock);
503
504 /* Put the inode at the front of the freelist */
505 mutex_enter(&ip->i_tlock);
506 mutex_enter(&udf_ifree_lock);
507 ud_add_to_free_list(ip, UD_BEGIN);
508 mutex_exit(&udf_ifree_lock);
509 ip->i_flag = 0;
510 mutex_exit(&ip->i_tlock);
511 rw_exit(&ip->i_contents);
512 return (EIO);
513 }
514
515 if (fe->fe_icb_tag.itag_strategy == SWAP_16(STRAT_TYPE4096)) {
516 struct buf *ibp = NULL;
517 struct indirect_entry *ie;
518
519 /*
520 * save old file_entry location
521 */
522 old_prn = ip->i_icb_prn;
523 old_block = ip->i_icb_block;
524 old_lbano = ip->i_icb_lbano;
525
526 ftype = STRAT_TYPE4096;
527
528 /*
529 * If astrat is 4096 different versions
530 * of the file exist on the media.
531 * we are supposed to get to the latest
532 * version of the file
533 */
534
535 /*
536 * IE is supposed to be in the next block
537 * of DE
538 */
539 ibp = ud_bread(ip->i_dev,
540 (ip->i_icb_lbano + 1) << udf_vfsp->udf_l2d_shift,
541 udf_vfsp->udf_lbsize);
542 if (ibp->b_flags & B_ERROR) {
543 /*
544 * Get rid of current ibp and
545 * then goto error on DE's bp
546 */
547 ie_error:
548 brelse(ibp);
549 goto error_ret;
550 }
551
552 ie = (struct indirect_entry *)ibp->b_un.b_addr;
553 if (ud_verify_tag_and_desc(&ie->ie_tag,
554 UD_INDIRECT_ENT, ip->i_icb_block + 1,
555 1, udf_vfsp->udf_lbsize) == 0) {
556 struct long_ad *lad;
557
558 lad = &ie->ie_indirecticb;
559 ip->i_icb_prn = SWAP_16(lad->lad_ext_prn);
560 ip->i_icb_block = SWAP_32(lad->lad_ext_loc);
561 ip->i_icb_lbano = ud_xlate_to_daddr(udf_vfsp,
562 ip->i_icb_prn, ip->i_icb_block,
563 1, &dummy);
564 brelse(ibp);
565 brelse(bp);
566 goto read_de;
567 }
568
569 /*
570 * If this block is TE or unrecorded we
571 * are at the last entry
572 */
573 if (ud_check_te_unrec(udf_vfsp, ibp->b_un.b_addr,
574 ip->i_icb_block + 1) != 0) {
575 /*
576 * This is not an unrecorded block
577 * Check if it a valid IE and
578 * get the address of DE that
579 * this IE points to
580 */
581 goto ie_error;
582 }
583 /*
584 * If ud_check_unrec returns "0"
585 * this is the last in the chain
586 * Latest file_entry
587 */
588 brelse(ibp);
589 }
590
591 end_4096:
592
593 ip->i_uid = SWAP_32(fe->fe_uid);
594 if (ip->i_uid == -1) {
595 ip->i_uid = ud_default_uid;
596 }
597 ip->i_gid = SWAP_32(fe->fe_gid);
598 if (ip->i_gid == -1) {
599 ip->i_gid = ud_default_gid;
600 }
601 ip->i_perm = SWAP_32(fe->fe_perms) & 0xFFFF;
602 if (fe->fe_icb_tag.itag_strategy == SWAP_16(STRAT_TYPE4096)) {
603 ip->i_perm &= ~(IWRITE | (IWRITE >> 5) | (IWRITE >> 10));
604 }
605
606 ip->i_nlink = SWAP_16(fe->fe_lcount);
607 ip->i_size = SWAP_64(fe->fe_info_len);
608 ip->i_lbr = SWAP_64(fe->fe_lbr);
609
610 ud_dtime2utime(&ip->i_atime, &fe->fe_acc_time);
611 ud_dtime2utime(&ip->i_mtime, &fe->fe_mod_time);
612 ud_dtime2utime(&ip->i_ctime, &fe->fe_attr_time);
613
614
615 ip->i_uniqid = SWAP_64(fe->fe_uniq_id);
616 icb_tag_flags = SWAP_16(fe->fe_icb_tag.itag_flags);
617
618 if ((fe->fe_icb_tag.itag_ftype == FTYPE_CHAR_DEV) ||
619 (fe->fe_icb_tag.itag_ftype == FTYPE_BLOCK_DEV)) {
620
621 eah = (struct ext_attr_hdr *)fe->fe_spec;
622 ea_off = GET_32(&eah->eah_ial);
623 ea_len = GET_32(&fe->fe_len_ear);
624 if (ea_len && (ud_verify_tag_and_desc(&eah->eah_tag,
625 UD_EXT_ATTR_HDR, ip->i_icb_block, 1,
626 sizeof (struct file_entry) -
627 offsetof(struct file_entry, fe_spec)) == 0)) {
628
629 while (ea_off < ea_len) {
630 /*
631 * We now check the validity of ea_off.
632 * (ea_len - ea_off) should be large enough to
633 * hold the attribute header atleast.
634 */
635 if ((ea_len - ea_off) <
636 sizeof (struct attr_hdr)) {
637 cmn_err(CE_NOTE,
638 "ea_len(0x%x) - ea_off(0x%x) is "
639 "too small to hold attr. info. "
640 "blockno 0x%x\n",
641 ea_len, ea_off, ip->i_icb_block);
642 goto error_ret;
643 }
644 ah = (struct attr_hdr *)&fe->fe_spec[ea_off];
645
646 /*
647 * Device Specification EA
648 */
649 if ((GET_32(&ah->ahdr_atype) == 12) &&
650 (ah->ahdr_astype == 1)) {
651 struct dev_spec_ear *ds;
652
653 if ((ea_len - ea_off) <
654 sizeof (struct dev_spec_ear)) {
655 cmn_err(CE_NOTE,
656 "ea_len(0x%x) - "
657 "ea_off(0x%x) is too small "
658 "to hold dev_spec_ear."
659 " blockno 0x%x\n",
660 ea_len, ea_off,
661 ip->i_icb_block);
662 goto error_ret;
663 }
664 ds = (struct dev_spec_ear *)ah;
665 ip->i_major = GET_32(&ds->ds_major_id);
666 ip->i_minor = GET_32(&ds->ds_minor_id);
667 }
668
669 /*
670 * Impl Use EA
671 */
672 if ((GET_32(&ah->ahdr_atype) == 2048) &&
673 (ah->ahdr_astype == 1)) {
674 struct iu_ea *iuea;
675 struct copy_mgt_info *cmi;
676
677 if ((ea_len - ea_off) <
678 sizeof (struct iu_ea)) {
679 cmn_err(CE_NOTE,
680 "ea_len(0x%x) - ea_off(0x%x) is too small to hold iu_ea. blockno 0x%x\n",
681 ea_len, ea_off,
682 ip->i_icb_block);
683 goto error_ret;
684 }
685 iuea = (struct iu_ea *)ah;
686 if (strncmp(iuea->iuea_ii.reg_id,
687 UDF_FREEEASPACE,
688 sizeof (iuea->iuea_ii.reg_id))
689 == 0) {
690 /* skip it */
691 iuea = iuea;
692 } else if (strncmp(iuea->iuea_ii.reg_id,
693 UDF_CGMS_INFO,
694 sizeof (iuea->iuea_ii.reg_id))
695 == 0) {
696 cmi = (struct copy_mgt_info *)
697 iuea->iuea_iu;
698 cmi = cmi;
699 }
700 }
701 /* ??? PARANOIA */
702 if (GET_32(&ah->ahdr_length) == 0) {
703 break;
704 }
705 ea_off += GET_32(&ah->ahdr_length);
706 }
707 }
708 }
709
710 ip->i_nextr = 0;
711
712 ip->i_maxent = SWAP_16(fe->fe_icb_tag.itag_max_ent);
713 ip->i_astrat = SWAP_16(fe->fe_icb_tag.itag_strategy);
714
715 ip->i_desc_type = icb_tag_flags & 0x7;
716
717 /* Strictly Paranoia */
718 ip->i_ext = NULL;
719 ip->i_ext_count = ip->i_ext_used = 0;
720 ip->i_con = 0;
721 ip->i_con_count = ip->i_con_used = ip->i_con_read = 0;
722
723 ip->i_data_off = 0xB0 + SWAP_32(fe->fe_len_ear);
724 ip->i_max_emb = udf_vfsp->udf_lbsize - ip->i_data_off;
725 if (ip->i_desc_type == ICB_FLAG_SHORT_AD) {
726 /* Short allocation desc */
727 struct short_ad *sad;
728
729 ip->i_ext_used = 0;
730 ip->i_ext_count = ndesc =
731 SWAP_32(fe->fe_len_adesc) / sizeof (struct short_ad);
732 ip->i_ext_count =
733 ((ip->i_ext_count / EXT_PER_MALLOC) + 1) * EXT_PER_MALLOC;
734 ip->i_ext = (struct icb_ext *)kmem_zalloc(ip->i_ext_count *
735 sizeof (struct icb_ext), KM_SLEEP);
736 ip->i_cur_max_ext = ip->i_max_emb / sizeof (struct short_ad);
737 ip->i_cur_max_ext --;
738
739 if ((ip->i_astrat != STRAT_TYPE4) &&
740 (ip->i_astrat != STRAT_TYPE4096)) {
741 goto error_ret;
742 }
743
744 sad = (struct short_ad *)
745 (fe->fe_spec + SWAP_32(fe->fe_len_ear));
746 iext = ip->i_ext;
747 while (ndesc --) {
748 length = SWAP_32(sad->sad_ext_len);
749 if ((length & 0x3FFFFFFF) == 0) {
750 break;
751 }
752 if (((length >> 30) & IB_MASK) == IB_CON) {
753 if (ip->i_con == NULL) {
754 ip->i_con_count = EXT_PER_MALLOC;
755 ip->i_con_used = 0;
756 ip->i_con_read = 0;
757 ip->i_con = kmem_zalloc(
758 ip->i_con_count *
759 sizeof (struct icb_ext),
760 KM_SLEEP);
761 }
762 con = &ip->i_con[ip->i_con_used];
763 con->ib_prn = 0;
764 con->ib_block = SWAP_32(sad->sad_ext_loc);
765 con->ib_count = length & 0x3FFFFFFF;
766 con->ib_flags = (length >> 30) & IB_MASK;
767 ip->i_con_used++;
768 sad ++;
769 break;
770 }
771 iext->ib_prn = 0;
772 iext->ib_block = SWAP_32(sad->sad_ext_loc);
773 length = SWAP_32(sad->sad_ext_len);
774 iext->ib_count = length & 0x3FFFFFFF;
775 iext->ib_offset = offset;
776 iext->ib_marker1 = (uint32_t)0xAAAAAAAA;
777 iext->ib_marker2 = (uint32_t)0xBBBBBBBB;
778 offset += (iext->ib_count + udf_vfsp->udf_lbmask) &
779 (~udf_vfsp->udf_lbmask);
780
781 iext->ib_flags = (length >> 30) & IB_MASK;
782
783 ip->i_ext_used++;
784 iext++;
785 sad ++;
786 }
787 } else if (ip->i_desc_type == ICB_FLAG_LONG_AD) {
788 /* Long allocation desc */
789 struct long_ad *lad;
790
791 ip->i_ext_used = 0;
792 ip->i_ext_count = ndesc =
793 SWAP_32(fe->fe_len_adesc) / sizeof (struct long_ad);
794 ip->i_ext_count =
795 ((ip->i_ext_count / EXT_PER_MALLOC) + 1) * EXT_PER_MALLOC;
796 ip->i_ext = (struct icb_ext *)kmem_zalloc(ip->i_ext_count *
797 sizeof (struct icb_ext), KM_SLEEP);
798
799 ip->i_cur_max_ext = ip->i_max_emb / sizeof (struct long_ad);
800 ip->i_cur_max_ext --;
801
802 if ((ip->i_astrat != STRAT_TYPE4) &&
803 (ip->i_astrat != STRAT_TYPE4096)) {
804 goto error_ret;
805 }
806
807 lad = (struct long_ad *)
808 (fe->fe_spec + SWAP_32(fe->fe_len_ear));
809 iext = ip->i_ext;
810 while (ndesc --) {
811 length = SWAP_32(lad->lad_ext_len);
812 if ((length & 0x3FFFFFFF) == 0) {
813 break;
814 }
815 if (((length >> 30) & IB_MASK) == IB_CON) {
816 if (ip->i_con == NULL) {
817 ip->i_con_count = EXT_PER_MALLOC;
818 ip->i_con_used = 0;
819 ip->i_con_read = 0;
820 ip->i_con = kmem_zalloc(
821 ip->i_con_count *
822 sizeof (struct icb_ext),
823 KM_SLEEP);
824 }
825 con = &ip->i_con[ip->i_con_used];
826 con->ib_prn = SWAP_16(lad->lad_ext_prn);
827 con->ib_block = SWAP_32(lad->lad_ext_loc);
828 con->ib_count = length & 0x3FFFFFFF;
829 con->ib_flags = (length >> 30) & IB_MASK;
830 ip->i_con_used++;
831 lad ++;
832 break;
833 }
834 iext->ib_prn = SWAP_16(lad->lad_ext_prn);
835 iext->ib_block = SWAP_32(lad->lad_ext_loc);
836 iext->ib_count = length & 0x3FFFFFFF;
837 iext->ib_offset = offset;
838 iext->ib_marker1 = (uint32_t)0xAAAAAAAA;
839 iext->ib_marker2 = (uint32_t)0xBBBBBBBB;
840 offset += (iext->ib_count + udf_vfsp->udf_lbmask) &
841 (~udf_vfsp->udf_lbmask);
842
843 iext->ib_flags = (length >> 30) & IB_MASK;
844
845 ip->i_ext_used++;
846 iext++;
847 lad ++;
848 }
849 } else if (ip->i_desc_type == ICB_FLAG_ONE_AD) {
850 ASSERT(SWAP_32(fe->fe_len_ear) < udf_vfsp->udf_lbsize);
851
852 if (SWAP_32(fe->fe_len_ear) > udf_vfsp->udf_lbsize) {
853 goto error_ret;
854 }
855 } else {
856 /* Not to be used in UDF 1.50 */
857 cmn_err(CE_NOTE, "Invalid Allocation Descriptor type %x\n",
858 ip->i_desc_type);
859 goto error_ret;
860 }
861
862
863 if (icb_tag_flags & ICB_FLAG_SETUID) {
864 ip->i_char = ISUID;
865 } else {
866 ip->i_char = 0;
867 }
868 if (icb_tag_flags & ICB_FLAG_SETGID) {
869 ip->i_char |= ISGID;
870 }
871 if (icb_tag_flags & ICB_FLAG_STICKY) {
872 ip->i_char |= ISVTX;
873 }
874 switch (fe->fe_icb_tag.itag_ftype) {
875 case FTYPE_DIRECTORY :
876 ip->i_type = VDIR;
877 break;
878 case FTYPE_FILE :
879 ip->i_type = VREG;
880 break;
881 case FTYPE_BLOCK_DEV :
882 ip->i_type = VBLK;
883 break;
884 case FTYPE_CHAR_DEV :
885 ip->i_type = VCHR;
886 break;
887 case FTYPE_FIFO :
888 ip->i_type = VFIFO;
889 break;
890 case FTYPE_C_ISSOCK :
891 ip->i_type = VSOCK;
892 break;
893 case FTYPE_SYMLINK :
894 ip->i_type = VLNK;
895 break;
896 default :
897 ip->i_type = VNON;
898 break;
899 }
900
901 if (ip->i_type == VBLK || ip->i_type == VCHR) {
902 ip->i_rdev = makedevice(ip->i_major, ip->i_minor);
903 }
904
905 /*
906 * Fill in the rest. Don't bother with the vnode lock because nobody
907 * should be looking at this vnode. We have already invalidated the
908 * pages if it had any so pageout shouldn't be referencing this vnode
909 * and we are holding the write contents lock so a look up can't use
910 * the vnode.
911 */
912 vp->v_vfsp = vfsp;
913 vp->v_type = ip->i_type;
914 vp->v_rdev = ip->i_rdev;
915 if (ip->i_udf->udf_root_blkno == loc) {
916 vp->v_flag = VROOT;
917 } else {
918 vp->v_flag = 0;
919 }
920
921 brelse(bp);
922 *ipp = ip;
923 rw_exit(&ip->i_contents);
924 vn_exists(vp);
925 return (0);
926 }
927
928 void
929 ud_iinactive(struct ud_inode *ip, struct cred *cr)
930 {
931 int32_t busy = 0;
932 struct vnode *vp;
933 vtype_t type;
934 caddr_t addr, addr1;
935 size_t size, size1;
936
937
938 ud_printf("ud_iinactive\n");
939
940 /*
941 * Get exclusive access to inode data.
942 */
943 rw_enter(&ip->i_contents, RW_WRITER);
944
945 /*
946 * Make sure no one reclaimed the inode before we put
947 * it on the freelist or destroy it. We keep our 'hold'
948 * on the vnode from vn_rele until we are ready to
949 * do something with the inode (freelist/destroy).
950 *
951 * Pageout may put a VN_HOLD/VN_RELE at anytime during this
952 * operation via an async putpage, so we must make sure
953 * we don't free/destroy the inode more than once. ud_iget
954 * may also put a VN_HOLD on the inode before it grabs
955 * the i_contents lock. This is done so we don't kmem_free
956 * an inode that a thread is waiting on.
957 */
958 vp = ITOV(ip);
959
960 mutex_enter(&vp->v_lock);
961 if (vp->v_count < 1) {
962 cmn_err(CE_WARN, "ud_iinactive: v_count < 1\n");
963 return;
964 }
965 if ((vp->v_count > 1) || ((ip->i_flag & IREF) == 0)) {
966 VN_RELE_LOCKED(vp);
967 mutex_exit(&vp->v_lock);
968 rw_exit(&ip->i_contents);
969 return;
970 }
971 mutex_exit(&vp->v_lock);
972
973 /*
974 * For forced umount case: if i_udf is NULL, the contents of
975 * the inode and all the pages have already been pushed back
976 * to disk. It can be safely destroyed.
977 */
978 if (ip->i_udf == NULL) {
979 addr = (caddr_t)ip->i_ext;
980 size = sizeof (struct icb_ext) * ip->i_ext_count;
981 ip->i_ext = 0;
982 ip->i_ext_count = ip->i_ext_used = 0;
983 addr1 = (caddr_t)ip->i_con;
984 size1 = sizeof (struct icb_ext) * ip->i_con_count;
985 ip->i_con = 0;
986 ip->i_con_count = ip->i_con_used = ip->i_con_read = 0;
987 rw_exit(&ip->i_contents);
988 vn_invalid(vp);
989
990 mutex_enter(&ud_nino_lock);
991 ud_cur_inodes--;
992 mutex_exit(&ud_nino_lock);
993
994 cv_destroy(&ip->i_wrcv); /* throttling */
995 rw_destroy(&ip->i_rwlock);
996 rw_exit(&ip->i_contents);
997 rw_destroy(&ip->i_contents);
998 kmem_free(addr, size);
999 kmem_free(addr1, size1);
1000 vn_free(vp);
1001 kmem_free(ip, sizeof (struct ud_inode));
1002 return;
1003 }
1004
1005 if ((ip->i_udf->udf_flags & UDF_FL_RDONLY) == 0) {
1006 if (ip->i_nlink <= 0) {
1007 ip->i_marker3 = (uint32_t)0xDDDD0000;
1008 ip->i_nlink = 1; /* prevent free-ing twice */
1009 (void) ud_itrunc(ip, 0, 0, cr);
1010 type = ip->i_type;
1011 ip->i_perm = 0;
1012 ip->i_uid = 0;
1013 ip->i_gid = 0;
1014 ip->i_rdev = 0; /* Zero in core version of rdev */
1015 mutex_enter(&ip->i_tlock);
1016 ip->i_flag |= IUPD|ICHG;
1017 mutex_exit(&ip->i_tlock);
1018 ud_ifree(ip, type);
1019 ip->i_icb_prn = 0xFFFF;
1020 } else if (!IS_SWAPVP(vp)) {
1021 /*
1022 * Write the inode out if dirty. Pages are
1023 * written back and put on the freelist.
1024 */
1025 (void) ud_syncip(ip, B_FREE | B_ASYNC, 0);
1026 /*
1027 * Do nothing if inode is now busy -- inode may
1028 * have gone busy because ud_syncip
1029 * releases/reacquires the i_contents lock
1030 */
1031 mutex_enter(&vp->v_lock);
1032 if (vp->v_count > 1) {
1033 VN_RELE_LOCKED(vp);
1034 mutex_exit(&vp->v_lock);
1035 rw_exit(&ip->i_contents);
1036 return;
1037 }
1038 mutex_exit(&vp->v_lock);
1039 } else {
1040 ud_iupdat(ip, 0);
1041 }
1042 }
1043
1044
1045 /*
1046 * Put the inode on the end of the free list.
1047 * Possibly in some cases it would be better to
1048 * put the inode at the head of the free list,
1049 * (e.g.: where i_perm == 0 || i_number == 0)
1050 * but I will think about that later.
1051 * (i_number is rarely 0 - only after an i/o error in ud_iget,
1052 * where i_perm == 0, the inode will probably be wanted
1053 * again soon for an ialloc, so possibly we should keep it)
1054 */
1055 /*
1056 * If inode is invalid or there is no page associated with
1057 * this inode, put the inode in the front of the free list.
1058 * Since we have a VN_HOLD on the vnode, and checked that it
1059 * wasn't already on the freelist when we entered, we can safely
1060 * put it on the freelist even if another thread puts a VN_HOLD
1061 * on it (pageout/ud_iget).
1062 */
1063 tryagain:
1064 mutex_enter(&ud_nino_lock);
1065 if (vn_has_cached_data(vp)) {
1066 mutex_exit(&ud_nino_lock);
1067 mutex_enter(&vp->v_lock);
1068 VN_RELE_LOCKED(vp);
1069 mutex_exit(&vp->v_lock);
1070 mutex_enter(&ip->i_tlock);
1071 mutex_enter(&udf_ifree_lock);
1072 ud_add_to_free_list(ip, UD_END);
1073 mutex_exit(&udf_ifree_lock);
1074 ip->i_flag &= IMODTIME;
1075 mutex_exit(&ip->i_tlock);
1076 rw_exit(&ip->i_contents);
1077 } else if (busy || ud_cur_inodes < ud_max_inodes) {
1078 mutex_exit(&ud_nino_lock);
1079 /*
1080 * We're not over our high water mark, or it's
1081 * not safe to kmem_free the inode, so put it
1082 * on the freelist.
1083 */
1084 mutex_enter(&vp->v_lock);
1085 if (vn_has_cached_data(vp)) {
1086 cmn_err(CE_WARN, "ud_iinactive: v_pages not NULL\n");
1087 }
1088 VN_RELE_LOCKED(vp);
1089 mutex_exit(&vp->v_lock);
1090
1091 mutex_enter(&ip->i_tlock);
1092 mutex_enter(&udf_ifree_lock);
1093 ud_add_to_free_list(ip, UD_BEGIN);
1094 mutex_exit(&udf_ifree_lock);
1095 ip->i_flag &= IMODTIME;
1096 mutex_exit(&ip->i_tlock);
1097 rw_exit(&ip->i_contents);
1098 } else {
1099 mutex_exit(&ud_nino_lock);
1100 if (vn_has_cached_data(vp)) {
1101 cmn_err(CE_WARN, "ud_iinactive: v_pages not NULL\n");
1102 }
1103 /*
1104 * Try to free the inode. We must make sure
1105 * it's o.k. to destroy this inode. We can't destroy
1106 * if a thread is waiting for this inode. If we can't get the
1107 * cache now, put it back on the freelist.
1108 */
1109 if (!mutex_tryenter(&ud_icache_lock)) {
1110 busy = 1;
1111 goto tryagain;
1112 }
1113 mutex_enter(&vp->v_lock);
1114 if (vp->v_count > 1) {
1115 /* inode is wanted in ud_iget */
1116 busy = 1;
1117 mutex_exit(&vp->v_lock);
1118 mutex_exit(&ud_icache_lock);
1119 goto tryagain;
1120 }
1121 mutex_exit(&vp->v_lock);
1122 remque(ip);
1123 ip->i_forw = ip;
1124 ip->i_back = ip;
1125 mutex_enter(&ud_nino_lock);
1126 ud_cur_inodes--;
1127 mutex_exit(&ud_nino_lock);
1128 mutex_exit(&ud_icache_lock);
1129 if (ip->i_icb_prn != 0xFFFF) {
1130 ud_iupdat(ip, 0);
1131 }
1132 addr = (caddr_t)ip->i_ext;
1133 size = sizeof (struct icb_ext) * ip->i_ext_count;
1134 ip->i_ext = 0;
1135 ip->i_ext_count = ip->i_ext_used = 0;
1136 addr1 = (caddr_t)ip->i_con;
1137 size1 = sizeof (struct icb_ext) * ip->i_con_count;
1138 ip->i_con = 0;
1139 ip->i_con_count = ip->i_con_used = ip->i_con_read = 0;
1140 cv_destroy(&ip->i_wrcv); /* throttling */
1141 rw_destroy(&ip->i_rwlock);
1142 rw_exit(&ip->i_contents);
1143 rw_destroy(&ip->i_contents);
1144 kmem_free(addr, size);
1145 kmem_free(addr1, size1);
1146 ip->i_marker3 = (uint32_t)0xDDDDDDDD;
1147 vn_free(vp);
1148 kmem_free(ip, sizeof (struct ud_inode));
1149 }
1150 }
1151
1152
1153 void
1154 ud_iupdat(struct ud_inode *ip, int32_t waitfor)
1155 {
1156 uint16_t flag, tag_flags;
1157 int32_t error;
1158 struct buf *bp;
1159 struct udf_vfs *udf_vfsp;
1160 struct file_entry *fe;
1161 uint16_t crc_len = 0;
1162
1163 ASSERT(RW_WRITE_HELD(&ip->i_contents));
1164
1165 ud_printf("ud_iupdat\n");
1166 /*
1167 * Return if file system has been forcibly umounted.
1168 */
1169 if (ip->i_udf == NULL) {
1170 return;
1171 }
1172
1173 udf_vfsp = ip->i_udf;
1174 flag = ip->i_flag; /* Atomic read */
1175 if ((flag & (IUPD|IACC|ICHG|IMOD|IMODACC)) != 0) {
1176 if (udf_vfsp->udf_flags & UDF_FL_RDONLY) {
1177 ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD|IMODACC|IATTCHG);
1178 return;
1179 }
1180
1181 bp = ud_bread(ip->i_dev,
1182 ip->i_icb_lbano << udf_vfsp->udf_l2d_shift,
1183 ip->i_udf->udf_lbsize);
1184 if (bp->b_flags & B_ERROR) {
1185 brelse(bp);
1186 return;
1187 }
1188 fe = (struct file_entry *)bp->b_un.b_addr;
1189 if (ud_verify_tag_and_desc(&fe->fe_tag, UD_FILE_ENTRY,
1190 ip->i_icb_block,
1191 1, ip->i_udf->udf_lbsize) != 0) {
1192 brelse(bp);
1193 return;
1194 }
1195
1196 mutex_enter(&ip->i_tlock);
1197 if (ip->i_flag & (IUPD|IACC|ICHG)) {
1198 IMARK(ip);
1199 }
1200 ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD|IMODACC);
1201 mutex_exit(&ip->i_tlock);
1202
1203 fe->fe_uid = SWAP_32(ip->i_uid);
1204 fe->fe_gid = SWAP_32(ip->i_gid);
1205
1206 fe->fe_perms = SWAP_32(ip->i_perm);
1207
1208 fe->fe_lcount = SWAP_16(ip->i_nlink);
1209 fe->fe_info_len = SWAP_64(ip->i_size);
1210 fe->fe_lbr = SWAP_64(ip->i_lbr);
1211
1212 ud_utime2dtime(&ip->i_atime, &fe->fe_acc_time);
1213 ud_utime2dtime(&ip->i_mtime, &fe->fe_mod_time);
1214 ud_utime2dtime(&ip->i_ctime, &fe->fe_attr_time);
1215
1216 if (ip->i_char & ISUID) {
1217 tag_flags = ICB_FLAG_SETUID;
1218 } else {
1219 tag_flags = 0;
1220 }
1221 if (ip->i_char & ISGID) {
1222 tag_flags |= ICB_FLAG_SETGID;
1223 }
1224 if (ip->i_char & ISVTX) {
1225 tag_flags |= ICB_FLAG_STICKY;
1226 }
1227 tag_flags |= ip->i_desc_type;
1228
1229 /*
1230 * Remove the following it is no longer contig
1231 * if (ip->i_astrat == STRAT_TYPE4) {
1232 * tag_flags |= ICB_FLAG_CONTIG;
1233 * }
1234 */
1235
1236 fe->fe_icb_tag.itag_flags &= ~SWAP_16((uint16_t)0x3C3);
1237 fe->fe_icb_tag.itag_strategy = SWAP_16(ip->i_astrat);
1238 fe->fe_icb_tag.itag_flags |= SWAP_16(tag_flags);
1239
1240 ud_update_regid(&fe->fe_impl_id);
1241
1242 crc_len = offsetof(struct file_entry, fe_spec) +
1243 SWAP_32(fe->fe_len_ear);
1244 if (ip->i_desc_type == ICB_FLAG_ONE_AD) {
1245 crc_len += ip->i_size;
1246 fe->fe_len_adesc = SWAP_32(((uint32_t)ip->i_size));
1247 } else if ((ip->i_size != 0) && (ip->i_ext != NULL) &&
1248 (ip->i_ext_used != 0)) {
1249
1250 if ((error = ud_read_icb_till_off(ip,
1251 ip->i_size)) == 0) {
1252 if (ip->i_astrat == STRAT_TYPE4) {
1253 error = ud_updat_ext4(ip, fe);
1254 } else if (ip->i_astrat == STRAT_TYPE4096) {
1255 error = ud_updat_ext4096(ip, fe);
1256 }
1257 if (error) {
1258 udf_vfsp->udf_mark_bad = 1;
1259 }
1260 }
1261 crc_len += SWAP_32(fe->fe_len_adesc);
1262 } else {
1263 fe->fe_len_adesc = 0;
1264 }
1265
1266 /*
1267 * Zero out the rest of the block
1268 */
1269 bzero(bp->b_un.b_addr + crc_len,
1270 ip->i_udf->udf_lbsize - crc_len);
1271
1272 ud_make_tag(ip->i_udf, &fe->fe_tag,
1273 UD_FILE_ENTRY, ip->i_icb_block, crc_len);
1274
1275
1276 if (waitfor) {
1277 BWRITE(bp);
1278
1279 /*
1280 * Synchronous write has guaranteed that inode
1281 * has been written on disk so clear the flag
1282 */
1283 ip->i_flag &= ~(IBDWRITE);
1284 } else {
1285 bdwrite(bp);
1286
1287 /*
1288 * This write hasn't guaranteed that inode has been
1289 * written on the disk.
1290 * Since, all updat flags on indoe are cleared, we must
1291 * remember the condition in case inode is to be updated
1292 * synchronously later (e.g.- fsync()/fdatasync())
1293 * and inode has not been modified yet.
1294 */
1295 ip->i_flag |= (IBDWRITE);
1296 }
1297 } else {
1298 /*
1299 * In case previous inode update was done asynchronously
1300 * (IBDWRITE) and this inode update request wants guaranteed
1301 * (synchronous) disk update, flush the inode.
1302 */
1303 if (waitfor && (flag & IBDWRITE)) {
1304 blkflush(ip->i_dev,
1305 (daddr_t)fsbtodb(udf_vfsp, ip->i_icb_lbano));
1306 ip->i_flag &= ~(IBDWRITE);
1307 }
1308 }
1309 }
1310
1311 int32_t
1312 ud_updat_ext4(struct ud_inode *ip, struct file_entry *fe)
1313 {
1314 uint32_t dummy;
1315 int32_t elen, ndent, index, count, con_index;
1316 daddr_t bno;
1317 struct buf *bp;
1318 struct short_ad *sad;
1319 struct long_ad *lad;
1320 struct icb_ext *iext, *icon;
1321
1322
1323 ASSERT(ip);
1324 ASSERT(fe);
1325 ASSERT((ip->i_desc_type == ICB_FLAG_SHORT_AD) ||
1326 (ip->i_desc_type == ICB_FLAG_LONG_AD));
1327
1328 if (ip->i_desc_type == ICB_FLAG_SHORT_AD) {
1329 elen = sizeof (struct short_ad);
1330 sad = (struct short_ad *)
1331 (fe->fe_spec + SWAP_32(fe->fe_len_ear));
1332 } else if (ip->i_desc_type == ICB_FLAG_LONG_AD) {
1333 elen = sizeof (struct long_ad);
1334 lad = (struct long_ad *)
1335 (fe->fe_spec + SWAP_32(fe->fe_len_ear));
1336 } else {
1337 /* This cannot happen return */
1338 return (EINVAL);
1339 }
1340
1341 ndent = ip->i_max_emb / elen;
1342
1343 if (ip->i_ext_used < ndent) {
1344
1345 if (ip->i_desc_type == ICB_FLAG_SHORT_AD) {
1346 ud_make_sad(ip->i_ext, sad, ip->i_ext_used);
1347 } else {
1348 ud_make_lad(ip->i_ext, lad, ip->i_ext_used);
1349 }
1350 fe->fe_len_adesc = SWAP_32(ip->i_ext_used * elen);
1351 con_index = 0;
1352 } else {
1353
1354 con_index = index = 0;
1355
1356 while (index < ip->i_ext_used) {
1357 if (index == 0) {
1358 /*
1359 * bp is already read
1360 * First few extents will go
1361 * into the file_entry
1362 */
1363 count = ndent - 1;
1364 fe->fe_len_adesc = SWAP_32(ndent * elen);
1365 bp = NULL;
1366
1367 /*
1368 * Last entry to be cont ext
1369 */
1370 icon = &ip->i_con[con_index];
1371 } else {
1372 /*
1373 * Read the buffer
1374 */
1375 icon = &ip->i_con[con_index];
1376
1377 bno = ud_xlate_to_daddr(ip->i_udf,
1378 icon->ib_prn, icon->ib_block,
1379 icon->ib_count >> ip->i_udf->udf_l2d_shift,
1380 &dummy);
1381 bp = ud_bread(ip->i_dev,
1382 bno << ip->i_udf->udf_l2d_shift,
1383 ip->i_udf->udf_lbsize);
1384 if (bp->b_flags & B_ERROR) {
1385 brelse(bp);
1386 return (EIO);
1387 }
1388
1389 /*
1390 * Figure out how many extents in
1391 * this time
1392 */
1393 count = (bp->b_bcount -
1394 sizeof (struct alloc_ext_desc)) / elen;
1395 if (count > (ip->i_ext_used - index)) {
1396 count = ip->i_ext_used - index;
1397 } else {
1398 count --;
1399 }
1400 con_index++;
1401 if (con_index >= ip->i_con_used) {
1402 icon = NULL;
1403 } else {
1404 icon = &ip->i_con[con_index];
1405 }
1406 }
1407
1408
1409
1410 /*
1411 * convert to on disk form and
1412 * update
1413 */
1414 iext = &ip->i_ext[index];
1415 if (ip->i_desc_type == ICB_FLAG_SHORT_AD) {
1416 if (index != 0) {
1417 sad = (struct short_ad *)
1418 (bp->b_un.b_addr +
1419 sizeof (struct alloc_ext_desc));
1420 }
1421 ud_make_sad(iext, sad, count);
1422 sad += count;
1423 if (icon != NULL) {
1424 ud_make_sad(icon, sad, 1);
1425 }
1426 } else {
1427 if (index != 0) {
1428 lad = (struct long_ad *)
1429 (bp->b_un.b_addr +
1430 sizeof (struct alloc_ext_desc));
1431 }
1432 ud_make_lad(iext, lad, count);
1433 lad += count;
1434 if (icon != NULL) {
1435 ud_make_lad(icon, lad, 1);
1436 }
1437 }
1438
1439 if (con_index != 0) {
1440 struct alloc_ext_desc *aed;
1441 int32_t sz;
1442 struct icb_ext *oicon;
1443
1444 oicon = &ip->i_con[con_index - 1];
1445 sz = count * elen;
1446 if (icon != NULL) {
1447 sz += elen;
1448 }
1449 aed = (struct alloc_ext_desc *)bp->b_un.b_addr;
1450 aed->aed_len_aed = SWAP_32(sz);
1451 if (con_index == 1) {
1452 aed->aed_rev_ael =
1453 SWAP_32(ip->i_icb_block);
1454 } else {
1455 aed->aed_rev_ael =
1456 SWAP_32(oicon->ib_block);
1457 }
1458 sz += sizeof (struct alloc_ext_desc);
1459 ud_make_tag(ip->i_udf, &aed->aed_tag,
1460 UD_ALLOC_EXT_DESC, oicon->ib_block, sz);
1461 }
1462
1463 /*
1464 * Write back to disk
1465 */
1466 if (bp != NULL) {
1467 BWRITE(bp);
1468 }
1469 index += count;
1470 }
1471
1472 }
1473
1474 if (con_index != ip->i_con_used) {
1475 int32_t lbmask, l2b, temp;
1476
1477 temp = con_index;
1478 lbmask = ip->i_udf->udf_lbmask;
1479 l2b = ip->i_udf->udf_l2b_shift;
1480 /*
1481 * Free unused continuation extents
1482 */
1483 for (; con_index < ip->i_con_used; con_index++) {
1484 icon = &ip->i_con[con_index];
1485 count = (icon->ib_count + lbmask) >> l2b;
1486 ud_free_space(ip->i_udf->udf_vfs, icon->ib_prn,
1487 icon->ib_block, count);
1488 count = (count << l2b) - sizeof (struct alloc_ext_desc);
1489 ip->i_cur_max_ext -= (count / elen) - 1;
1490 }
1491 ip->i_con_used = temp;
1492 }
1493 return (0);
1494 }
1495
1496 /* ARGSUSED */
1497 int32_t
1498 ud_updat_ext4096(struct ud_inode *ip, struct file_entry *fe)
1499 {
1500 return (ENXIO);
1501 }
1502
1503 void
1504 ud_make_sad(struct icb_ext *iext, struct short_ad *sad, int32_t count)
1505 {
1506 int32_t index = 0, scount;
1507
1508 ASSERT(iext);
1509 ASSERT(sad);
1510
1511 if (count != 0) {
1512 ASSERT(count > 0);
1513 while (index < count) {
1514 scount = (iext->ib_count & 0x3FFFFFFF) |
1515 (iext->ib_flags << 30);
1516 sad->sad_ext_len = SWAP_32(scount);
1517 sad->sad_ext_loc = SWAP_32(iext->ib_block);
1518 sad++;
1519 iext++;
1520 index++;
1521 }
1522 }
1523 }
1524
1525 void
1526 ud_make_lad(struct icb_ext *iext, struct long_ad *lad, int32_t count)
1527 {
1528 int32_t index = 0, scount;
1529
1530 ASSERT(iext);
1531 ASSERT(lad);
1532
1533 if (count != 0) {
1534 ASSERT(count > 0);
1535
1536 while (index < count) {
1537 lad->lad_ext_prn = SWAP_16(iext->ib_prn);
1538 scount = (iext->ib_count & 0x3FFFFFFF) |
1539 (iext->ib_flags << 30);
1540 lad->lad_ext_len = SWAP_32(scount);
1541 lad->lad_ext_loc = SWAP_32(iext->ib_block);
1542 lad++;
1543 iext++;
1544 index++;
1545 }
1546 }
1547 }
1548
1549 /*
1550 * Truncate the inode ip to at most length size.
1551 * Free affected disk blocks -- the blocks of the
1552 * file are removed in reverse order.
1553 */
1554 /* ARGSUSED */
1555 int
1556 ud_itrunc(struct ud_inode *oip, u_offset_t length,
1557 int32_t flags, struct cred *cr)
1558 {
1559 int32_t error, boff;
1560 off_t bsize;
1561 mode_t mode;
1562 struct udf_vfs *udf_vfsp;
1563
1564 ud_printf("ud_itrunc\n");
1565
1566 ASSERT(RW_WRITE_HELD(&oip->i_contents));
1567 udf_vfsp = oip->i_udf;
1568 bsize = udf_vfsp->udf_lbsize;
1569
1570 /*
1571 * We only allow truncation of regular files and directories
1572 * to arbritary lengths here. In addition, we allow symbolic
1573 * links to be truncated only to zero length. Other inode
1574 * types cannot have their length set here.
1575 */
1576 mode = oip->i_type;
1577 if (mode == VFIFO) {
1578 return (0);
1579 }
1580 if ((mode != VREG) && (mode != VDIR) &&
1581 (!(mode == VLNK && length == 0))) {
1582 return (EINVAL);
1583 }
1584 if (length == oip->i_size) {
1585 /* update ctime and mtime to please POSIX tests */
1586 mutex_enter(&oip->i_tlock);
1587 oip->i_flag |= ICHG |IUPD;
1588 mutex_exit(&oip->i_tlock);
1589 return (0);
1590 }
1591
1592 boff = blkoff(udf_vfsp, length);
1593
1594 if (length > oip->i_size) {
1595 /*
1596 * Trunc up case.ud_bmap_write will insure that the right blocks
1597 * are allocated. This includes doing any work needed for
1598 * allocating the last block.
1599 */
1600 if (boff == 0) {
1601 error = ud_bmap_write(oip, length - 1,
1602 (int)bsize, 0, cr);
1603 } else {
1604 error = ud_bmap_write(oip, length - 1, boff, 0, cr);
1605 }
1606 if (error == 0) {
1607 u_offset_t osize = oip->i_size;
1608 oip->i_size = length;
1609
1610 /*
1611 * Make sure we zero out the remaining bytes of
1612 * the page in case a mmap scribbled on it. We
1613 * can't prevent a mmap from writing beyond EOF
1614 * on the last page of a file.
1615 */
1616 if ((boff = blkoff(udf_vfsp, osize)) != 0) {
1617 pvn_vpzero(ITOV(oip), osize,
1618 (uint32_t)(bsize - boff));
1619 }
1620 mutex_enter(&oip->i_tlock);
1621 oip->i_flag |= ICHG;
1622 ITIMES_NOLOCK(oip);
1623 mutex_exit(&oip->i_tlock);
1624 }
1625 return (error);
1626 }
1627
1628 /*
1629 * Update the pages of the file. If the file is not being
1630 * truncated to a block boundary, the contents of the
1631 * pages following the end of the file must be zero'ed
1632 * in case it ever become accessable again because
1633 * of subsequent file growth.
1634 */
1635 if (boff == 0) {
1636 (void) pvn_vplist_dirty(ITOV(oip), length,
1637 ud_putapage, B_INVAL | B_TRUNC, CRED());
1638 } else {
1639 /*
1640 * Make sure that the last block is properly allocated.
1641 * We only really have to do this if the last block is
1642 * actually allocated. Just to be sure, we do it now
1643 * independent of current allocation.
1644 */
1645 error = ud_bmap_write(oip, length - 1, boff, 0, cr);
1646 if (error) {
1647 return (error);
1648 }
1649
1650 pvn_vpzero(ITOV(oip), length, (uint32_t)(bsize - boff));
1651
1652 (void) pvn_vplist_dirty(ITOV(oip), length,
1653 ud_putapage, B_INVAL | B_TRUNC, CRED());
1654 }
1655
1656
1657 /* Free the blocks */
1658 if (oip->i_desc_type == ICB_FLAG_ONE_AD) {
1659 if (length > oip->i_max_emb) {
1660 return (EFBIG);
1661 }
1662 oip->i_size = length;
1663 mutex_enter(&oip->i_tlock);
1664 oip->i_flag |= ICHG|IUPD;
1665 mutex_exit(&oip->i_tlock);
1666 ud_iupdat(oip, 1);
1667 } else {
1668 if ((error = ud_read_icb_till_off(oip, oip->i_size)) != 0) {
1669 return (error);
1670 }
1671
1672 if (oip->i_astrat == STRAT_TYPE4) {
1673 ud_trunc_ext4(oip, length);
1674 } else if (oip->i_astrat == STRAT_TYPE4096) {
1675 ud_trunc_ext4096(oip, length);
1676 }
1677 }
1678
1679 done:
1680 return (0);
1681 }
1682
1683 void
1684 ud_trunc_ext4(struct ud_inode *ip, u_offset_t length)
1685 {
1686 int32_t index, l2b, count, ecount;
1687 int32_t elen, ndent, nient;
1688 u_offset_t ext_beg, ext_end;
1689 struct icb_ext *iext, *icon;
1690 int32_t lbmask, ext_used;
1691 uint32_t loc;
1692 struct icb_ext text;
1693 uint32_t con_freed;
1694
1695 ASSERT((ip->i_desc_type == ICB_FLAG_SHORT_AD) ||
1696 (ip->i_desc_type == ICB_FLAG_LONG_AD));
1697
1698 if (ip->i_ext_used == 0) {
1699 return;
1700 }
1701
1702 ext_used = ip->i_ext_used;
1703
1704 lbmask = ip->i_udf->udf_lbmask;
1705 l2b = ip->i_udf->udf_l2b_shift;
1706
1707 ASSERT(ip->i_ext);
1708
1709 ip->i_lbr = 0;
1710 for (index = 0; index < ext_used; index++) {
1711 iext = &ip->i_ext[index];
1712
1713 /*
1714 * Find the begining and end
1715 * of current extent
1716 */
1717 ext_beg = iext->ib_offset;
1718 ext_end = iext->ib_offset +
1719 ((iext->ib_count + lbmask) & ~lbmask);
1720
1721 /*
1722 * This is the extent that has offset "length"
1723 * make a copy of this extent and
1724 * remember the index. We can use
1725 * it to free blocks
1726 */
1727 if ((length <= ext_end) && (length >= ext_beg)) {
1728 text = *iext;
1729
1730 iext->ib_count = length - ext_beg;
1731 ip->i_ext_used = index + 1;
1732 break;
1733 }
1734 if (iext->ib_flags != IB_UN_RE_AL) {
1735 ip->i_lbr += iext->ib_count >> l2b;
1736 }
1737 }
1738 if (ip->i_ext_used != index) {
1739 if (iext->ib_flags != IB_UN_RE_AL) {
1740 ip->i_lbr +=
1741 ((iext->ib_count + lbmask) & ~lbmask) >> l2b;
1742 }
1743 }
1744
1745 ip->i_size = length;
1746 mutex_enter(&ip->i_tlock);
1747 ip->i_flag |= ICHG|IUPD;
1748 mutex_exit(&ip->i_tlock);
1749 ud_iupdat(ip, 1);
1750
1751 /*
1752 * Free the unused space
1753 */
1754 if (text.ib_flags != IB_UN_RE_AL) {
1755 count = (ext_end - length) >> l2b;
1756 if (count) {
1757 loc = text.ib_block +
1758 (((length - text.ib_offset) + lbmask) >> l2b);
1759 ud_free_space(ip->i_udf->udf_vfs, text.ib_prn,
1760 loc, count);
1761 }
1762 }
1763 for (index = ip->i_ext_used; index < ext_used; index++) {
1764 iext = &ip->i_ext[index];
1765 if (iext->ib_flags != IB_UN_RE_AL) {
1766 count = (iext->ib_count + lbmask) >> l2b;
1767 ud_free_space(ip->i_udf->udf_vfs, iext->ib_prn,
1768 iext->ib_block, count);
1769 }
1770 bzero(iext, sizeof (struct icb_ext));
1771 continue;
1772 }
1773
1774 /*
1775 * release any continuation blocks
1776 */
1777 if (ip->i_con) {
1778
1779 ASSERT(ip->i_con_count >= ip->i_con_used);
1780
1781 /*
1782 * Find out how many indirect blocks
1783 * are required and release the rest
1784 */
1785 if (ip->i_desc_type == ICB_FLAG_SHORT_AD) {
1786 elen = sizeof (struct short_ad);
1787 } else if (ip->i_desc_type == ICB_FLAG_LONG_AD) {
1788 elen = sizeof (struct long_ad);
1789 }
1790 ndent = ip->i_max_emb / elen;
1791 if (ip->i_ext_used > ndent) {
1792 ecount = ip->i_ext_used - ndent;
1793 } else {
1794 ecount = 0;
1795 }
1796 con_freed = 0;
1797 for (index = 0; index < ip->i_con_used; index++) {
1798 icon = &ip->i_con[index];
1799 nient = icon->ib_count -
1800 (sizeof (struct alloc_ext_desc) + elen);
1801 /* Header + 1 indirect extent */
1802 nient /= elen;
1803 if (ecount) {
1804 if (ecount > nient) {
1805 ecount -= nient;
1806 } else {
1807 ecount = 0;
1808 }
1809 } else {
1810 count = ((icon->ib_count + lbmask) &
1811 ~lbmask) >> l2b;
1812 ud_free_space(ip->i_udf->udf_vfs,
1813 icon->ib_prn, icon->ib_block, count);
1814 con_freed++;
1815 ip->i_cur_max_ext -= nient;
1816 }
1817 }
1818 /*
1819 * set the continuation extents used(i_con_used)i to correct
1820 * value. It is possible for i_con_used to be zero,
1821 * if we free up all continuation extents. This happens
1822 * when ecount is 0 before entering the for loop above.
1823 */
1824 ip->i_con_used -= con_freed;
1825 if (ip->i_con_read > ip->i_con_used) {
1826 ip->i_con_read = ip->i_con_used;
1827 }
1828 }
1829 }
1830
1831 void
1832 ud_trunc_ext4096(struct ud_inode *ip, u_offset_t length)
1833 {
1834 /*
1835 * Truncate code is the same for
1836 * both file of type 4 and 4096
1837 */
1838 ud_trunc_ext4(ip, length);
1839 }
1840
1841 /*
1842 * Remove any inodes in the inode cache belonging to dev
1843 *
1844 * There should not be any active ones, return error if any are found but
1845 * still invalidate others (N.B.: this is a user error, not a system error).
1846 *
1847 * Also, count the references to dev by block devices - this really
1848 * has nothing to do with the object of the procedure, but as we have
1849 * to scan the inode table here anyway, we might as well get the
1850 * extra benefit.
1851 */
1852 int32_t
1853 ud_iflush(struct vfs *vfsp)
1854 {
1855 int32_t index, busy = 0;
1856 union ihead *ih;
1857 struct udf_vfs *udf_vfsp;
1858 dev_t dev;
1859 struct vnode *rvp, *vp;
1860 struct ud_inode *ip, *next;
1861
1862 ud_printf("ud_iflush\n");
1863 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data;
1864 rvp = udf_vfsp->udf_root;
1865 dev = vfsp->vfs_dev;
1866
1867 mutex_enter(&ud_icache_lock);
1868 for (index = 0; index < UD_HASH_SZ; index++) {
1869 ih = &ud_ihead[index];
1870
1871 next = ih->ih_chain[0];
1872 while (next != (struct ud_inode *)ih) {
1873 ip = next;
1874 next = ip->i_forw;
1875 if (ip->i_dev != dev) {
1876 continue;
1877 }
1878 vp = ITOV(ip);
1879 /*
1880 * root inode is processed by the caller
1881 */
1882 if (vp == rvp) {
1883 if (vp->v_count > 1) {
1884 busy = -1;
1885 }
1886 continue;
1887 }
1888 if (ip->i_flag & IREF) {
1889 /*
1890 * Set error indicator for return value,
1891 * but continue invalidating other
1892 * inodes.
1893 */
1894 busy = -1;
1895 continue;
1896 }
1897
1898 rw_enter(&ip->i_contents, RW_WRITER);
1899 remque(ip);
1900 ip->i_forw = ip;
1901 ip->i_back = ip;
1902 /*
1903 * Hold the vnode since its not done
1904 * in VOP_PUTPAGE anymore.
1905 */
1906 VN_HOLD(vp);
1907 /*
1908 * XXX Synchronous write holding
1909 * cache lock
1910 */
1911 (void) ud_syncip(ip, B_INVAL, I_SYNC);
1912 rw_exit(&ip->i_contents);
1913 VN_RELE(vp);
1914 }
1915 }
1916 mutex_exit(&ud_icache_lock);
1917
1918 return (busy);
1919 }
1920
1921
1922 /*
1923 * Check mode permission on inode. Mode is READ, WRITE or EXEC.
1924 * In the case of WRITE, the read-only status of the file system
1925 * is checked. The applicable mode bits are compared with the
1926 * requested form of access. If bits are missing, the secpolicy
1927 * function will check for privileges.
1928 */
1929 int
1930 ud_iaccess(struct ud_inode *ip, int32_t mode, struct cred *cr, int dolock)
1931 {
1932 int shift = 0;
1933 int ret = 0;
1934
1935 if (dolock)
1936 rw_enter(&ip->i_contents, RW_READER);
1937 ASSERT(RW_LOCK_HELD(&ip->i_contents));
1938
1939 ud_printf("ud_iaccess\n");
1940 if (mode & IWRITE) {
1941 /*
1942 * Disallow write attempts on read-only
1943 * file systems, unless the file is a block
1944 * or character device or a FIFO.
1945 */
1946 if (ip->i_udf->udf_flags & UDF_FL_RDONLY) {
1947 if ((ip->i_type != VCHR) &&
1948 (ip->i_type != VBLK) &&
1949 (ip->i_type != VFIFO)) {
1950 ret = EROFS;
1951 goto out;
1952 }
1953 }
1954 }
1955
1956 /*
1957 * Access check is based on only
1958 * one of owner, group, public.
1959 * If not owner, then check group.
1960 * If not a member of the group, then
1961 * check public access.
1962 */
1963 if (crgetuid(cr) != ip->i_uid) {
1964 shift += 5;
1965 if (!groupmember((uid_t)ip->i_gid, cr))
1966 shift += 5;
1967 }
1968
1969 ret = secpolicy_vnode_access2(cr, ITOV(ip), ip->i_uid,
1970 UD2VA_PERM(ip->i_perm << shift), UD2VA_PERM(mode));
1971
1972 out:
1973 if (dolock)
1974 rw_exit(&ip->i_contents);
1975 return (ret);
1976 }
1977
1978 void
1979 ud_imark(struct ud_inode *ip)
1980 {
1981 timestruc_t now;
1982
1983 gethrestime(&now);
1984 ud_printf("ud_imark\n");
1985 if (ip->i_flag & IACC) {
1986 ip->i_atime.tv_sec = now.tv_sec;
1987 ip->i_atime.tv_nsec = now.tv_nsec;
1988 }
1989 if (ip->i_flag & IUPD) {
1990 ip->i_mtime.tv_sec = now.tv_sec;
1991 ip->i_mtime.tv_nsec = now.tv_nsec;
1992 ip->i_flag |= IMODTIME;
1993 }
1994 if (ip->i_flag & ICHG) {
1995 ip->i_diroff = 0;
1996 ip->i_ctime.tv_sec = now.tv_sec;
1997 ip->i_ctime.tv_nsec = now.tv_nsec;
1998 }
1999 }
2000
2001
2002 void
2003 ud_itimes_nolock(struct ud_inode *ip)
2004 {
2005 ud_printf("ud_itimes_nolock\n");
2006
2007 if (ip->i_flag & (IUPD|IACC|ICHG)) {
2008 if (ip->i_flag & ICHG) {
2009 ip->i_flag |= IMOD;
2010 } else {
2011 ip->i_flag |= IMODACC;
2012 }
2013 ud_imark(ip);
2014 ip->i_flag &= ~(IACC|IUPD|ICHG);
2015 }
2016 }
2017
2018 void
2019 ud_delcache(struct ud_inode *ip)
2020 {
2021 ud_printf("ud_delcache\n");
2022
2023 mutex_enter(&ud_icache_lock);
2024 remque(ip);
2025 ip->i_forw = ip;
2026 ip->i_back = ip;
2027 mutex_exit(&ud_icache_lock);
2028 }
2029
2030 void
2031 ud_idrop(struct ud_inode *ip)
2032 {
2033 struct vnode *vp = ITOV(ip);
2034
2035 ASSERT(RW_WRITE_HELD(&ip->i_contents));
2036
2037 ud_printf("ud_idrop\n");
2038
2039 mutex_enter(&vp->v_lock);
2040 VN_RELE_LOCKED(vp);
2041 if (vp->v_count > 0) {
2042 mutex_exit(&vp->v_lock);
2043 return;
2044 }
2045 mutex_exit(&vp->v_lock);
2046
2047 /*
2048 * if inode is invalid or there is no page associated with
2049 * this inode, put the inode in the front of the free list
2050 */
2051 mutex_enter(&ip->i_tlock);
2052 mutex_enter(&udf_ifree_lock);
2053 if (!vn_has_cached_data(vp) || ip->i_perm == 0) {
2054 ud_add_to_free_list(ip, UD_BEGIN);
2055 } else {
2056 /*
2057 * Otherwise, put the inode back on the end of the free list.
2058 */
2059 ud_add_to_free_list(ip, UD_END);
2060 }
2061 mutex_exit(&udf_ifree_lock);
2062 ip->i_flag &= IMODTIME;
2063 mutex_exit(&ip->i_tlock);
2064 }
2065
2066 void
2067 ud_add_to_free_list(struct ud_inode *ip, uint32_t at)
2068 {
2069 ASSERT(ip);
2070 ASSERT(mutex_owned(&udf_ifree_lock));
2071
2072 #ifdef DEBUG
2073 /* Search if the element is already in the list */
2074 if (udf_ifreeh != NULL) {
2075 struct ud_inode *iq;
2076
2077 iq = udf_ifreeh;
2078 while (iq) {
2079 if (iq == ip) {
2080 cmn_err(CE_WARN, "Duplicate %p\n", (void *)ip);
2081 }
2082 iq = iq->i_freef;
2083 }
2084 }
2085 #endif
2086
2087 ip->i_freef = NULL;
2088 ip->i_freeb = NULL;
2089 if (udf_ifreeh == NULL) {
2090 /*
2091 * Nothing on the list just add it
2092 */
2093 udf_ifreeh = ip;
2094 udf_ifreet = ip;
2095 } else {
2096 if (at == UD_BEGIN) {
2097 /*
2098 * Add at the begining of the list
2099 */
2100 ip->i_freef = udf_ifreeh;
2101 udf_ifreeh->i_freeb = ip;
2102 udf_ifreeh = ip;
2103 } else {
2104 /*
2105 * Add at the end of the list
2106 */
2107 ip->i_freeb = udf_ifreet;
2108 udf_ifreet->i_freef = ip;
2109 udf_ifreet = ip;
2110 }
2111 }
2112 }
2113
2114 void
2115 ud_remove_from_free_list(struct ud_inode *ip, uint32_t at)
2116 {
2117 ASSERT(ip);
2118 ASSERT(mutex_owned(&udf_ifree_lock));
2119
2120 #ifdef DEBUG
2121 {
2122 struct ud_inode *iq;
2123 uint32_t found = 0;
2124
2125 iq = udf_ifreeh;
2126 while (iq) {
2127 if (iq == ip) {
2128 found++;
2129 }
2130 iq = iq->i_freef;
2131 }
2132 if (found != 1) {
2133 cmn_err(CE_WARN, "ip %p is found %x times\n",
2134 (void *)ip, found);
2135 }
2136 }
2137 #endif
2138
2139 if ((ip->i_freef == NULL) && (ip->i_freeb == NULL)) {
2140 if (ip != udf_ifreeh) {
2141 return;
2142 }
2143 }
2144
2145 if ((at == UD_BEGIN) || (ip == udf_ifreeh)) {
2146 udf_ifreeh = ip->i_freef;
2147 if (ip->i_freef == NULL) {
2148 udf_ifreet = NULL;
2149 } else {
2150 udf_ifreeh->i_freeb = NULL;
2151 }
2152 } else {
2153 ip->i_freeb->i_freef = ip->i_freef;
2154 if (ip->i_freef) {
2155 ip->i_freef->i_freeb = ip->i_freeb;
2156 } else {
2157 udf_ifreet = ip->i_freeb;
2158 }
2159 }
2160 ip->i_freef = NULL;
2161 ip->i_freeb = NULL;
2162 }
2163
2164 void
2165 ud_init_inodes(void)
2166 {
2167 union ihead *ih = ud_ihead;
2168 int index;
2169
2170 #ifndef __lint
2171 _NOTE(NO_COMPETING_THREADS_NOW);
2172 #endif
2173 for (index = 0; index < UD_HASH_SZ; index++, ih++) {
2174 ih->ih_head[0] = ih;
2175 ih->ih_head[1] = ih;
2176 }
2177 mutex_init(&ud_icache_lock, NULL, MUTEX_DEFAULT, NULL);
2178 mutex_init(&ud_nino_lock, NULL, MUTEX_DEFAULT, NULL);
2179
2180 udf_ifreeh = NULL;
2181 udf_ifreet = NULL;
2182 mutex_init(&udf_ifree_lock, NULL, MUTEX_DEFAULT, NULL);
2183
2184 mutex_init(&ud_sync_busy, NULL, MUTEX_DEFAULT, NULL);
2185 udf_vfs_instances = NULL;
2186 mutex_init(&udf_vfs_mutex, NULL, MUTEX_DEFAULT, NULL);
2187
2188 #ifndef __lint
2189 _NOTE(COMPETING_THREADS_NOW);
2190 #endif
2191 }