Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/tmpfs/tmp_vnops.c
+++ new/usr/src/uts/common/fs/tmpfs/tmp_vnops.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 /*
28 - * Copyright 2016 Joyent, Inc.
28 + * Copyright 2016, Joyent, Inc.
29 29 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
30 30 * Copyright 2016 RackTop Systems.
31 31 */
32 32
33 33 #include <sys/types.h>
34 34 #include <sys/param.h>
35 35 #include <sys/t_lock.h>
36 36 #include <sys/systm.h>
37 37 #include <sys/sysmacros.h>
38 38 #include <sys/user.h>
39 39 #include <sys/time.h>
40 40 #include <sys/vfs.h>
41 41 #include <sys/vfs_opreg.h>
42 42 #include <sys/vnode.h>
43 43 #include <sys/file.h>
44 44 #include <sys/fcntl.h>
45 45 #include <sys/flock.h>
46 46 #include <sys/kmem.h>
47 47 #include <sys/uio.h>
48 48 #include <sys/errno.h>
49 49 #include <sys/stat.h>
50 50 #include <sys/cred.h>
51 51 #include <sys/dirent.h>
52 52 #include <sys/pathname.h>
53 53 #include <sys/vmsystm.h>
54 54 #include <sys/fs/tmp.h>
55 55 #include <sys/fs/tmpnode.h>
56 56 #include <sys/mman.h>
57 57 #include <vm/hat.h>
58 58 #include <vm/seg_vn.h>
59 59 #include <vm/seg_map.h>
60 60 #include <vm/seg.h>
61 61 #include <vm/anon.h>
62 62 #include <vm/as.h>
63 63 #include <vm/page.h>
64 64 #include <vm/pvn.h>
65 65 #include <sys/cmn_err.h>
66 66 #include <sys/debug.h>
67 67 #include <sys/swap.h>
68 68 #include <sys/buf.h>
69 69 #include <sys/vm.h>
70 70 #include <sys/vtrace.h>
71 71 #include <sys/policy.h>
72 72 #include <fs/fs_subr.h>
73 73
74 74 static int tmp_getapage(struct vnode *, u_offset_t, size_t, uint_t *,
75 75 page_t **, size_t, struct seg *, caddr_t, enum seg_rw, struct cred *);
76 76 static int tmp_putapage(struct vnode *, page_t *, u_offset_t *, size_t *,
77 77 int, struct cred *);
78 78
79 79 /* ARGSUSED1 */
80 80 static int
81 81 tmp_open(struct vnode **vpp, int flag, struct cred *cred, caller_context_t *ct)
82 82 {
83 83 /*
84 84 * swapon to a tmpfs file is not supported so access
85 85 * is denied on open if VISSWAP is set.
86 86 */
87 87 if ((*vpp)->v_flag & VISSWAP)
88 88 return (EINVAL);
89 89 return (0);
90 90 }
91 91
92 92 /* ARGSUSED1 */
93 93 static int
94 94 tmp_close(
95 95 struct vnode *vp,
96 96 int flag,
97 97 int count,
98 98 offset_t offset,
99 99 struct cred *cred,
100 100 caller_context_t *ct)
101 101 {
102 102 cleanlocks(vp, ttoproc(curthread)->p_pid, 0);
103 103 cleanshares(vp, ttoproc(curthread)->p_pid);
104 104 return (0);
105 105 }
106 106
107 107 /*
108 108 * wrtmp does the real work of write requests for tmpfs.
109 109 */
110 110 static int
111 111 wrtmp(
112 112 struct tmount *tm,
113 113 struct tmpnode *tp,
114 114 struct uio *uio,
115 115 struct cred *cr,
116 116 struct caller_context *ct)
117 117 {
118 118 pgcnt_t pageoffset; /* offset in pages */
119 119 ulong_t segmap_offset; /* pagesize byte offset into segmap */
120 120 caddr_t base; /* base of segmap */
121 121 ssize_t bytes; /* bytes to uiomove */
122 122 pfn_t pagenumber; /* offset in pages into tmp file */
123 123 struct vnode *vp;
124 124 int error = 0;
125 125 int pagecreate; /* == 1 if we allocated a page */
126 126 int newpage;
127 127 rlim64_t limit = uio->uio_llimit;
128 128 long oresid = uio->uio_resid;
129 129 timestruc_t now;
130 130
131 131 long tn_size_changed = 0;
132 132 long old_tn_size;
133 133 long new_tn_size;
134 134
135 135 vp = TNTOV(tp);
136 136 ASSERT(vp->v_type == VREG);
137 137
138 138 TRACE_1(TR_FAC_TMPFS, TR_TMPFS_RWTMP_START,
139 139 "tmp_wrtmp_start:vp %p", vp);
140 140
141 141 ASSERT(RW_WRITE_HELD(&tp->tn_contents));
142 142 ASSERT(RW_WRITE_HELD(&tp->tn_rwlock));
143 143
144 144 if (MANDLOCK(vp, tp->tn_mode)) {
145 145 rw_exit(&tp->tn_contents);
146 146 /*
147 147 * tmp_getattr ends up being called by chklock
148 148 */
149 149 error = chklock(vp, FWRITE, uio->uio_loffset, uio->uio_resid,
150 150 uio->uio_fmode, ct);
151 151 rw_enter(&tp->tn_contents, RW_WRITER);
152 152 if (error != 0) {
153 153 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
154 154 "tmp_wrtmp_end:vp %p error %d", vp, error);
155 155 return (error);
156 156 }
157 157 }
158 158
159 159 if (uio->uio_loffset < 0)
160 160 return (EINVAL);
161 161
162 162 if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T)
163 163 limit = MAXOFFSET_T;
164 164
165 165 if (uio->uio_loffset >= limit) {
166 166 proc_t *p = ttoproc(curthread);
167 167
168 168 mutex_enter(&p->p_lock);
169 169 (void) rctl_action(rctlproc_legacy[RLIMIT_FSIZE], p->p_rctls,
170 170 p, RCA_UNSAFE_SIGINFO);
171 171 mutex_exit(&p->p_lock);
172 172 return (EFBIG);
173 173 }
174 174
175 175 if (uio->uio_loffset >= MAXOFF_T) {
176 176 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
177 177 "tmp_wrtmp_end:vp %p error %d", vp, EINVAL);
178 178 return (EFBIG);
179 179 }
180 180
181 181 if (uio->uio_resid == 0) {
182 182 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
183 183 "tmp_wrtmp_end:vp %p error %d", vp, 0);
184 184 return (0);
185 185 }
186 186
187 187 if (limit > MAXOFF_T)
188 188 limit = MAXOFF_T;
189 189
190 190 do {
191 191 long offset;
192 192 long delta;
193 193
194 194 offset = (long)uio->uio_offset;
195 195 pageoffset = offset & PAGEOFFSET;
196 196 /*
197 197 * A maximum of PAGESIZE bytes of data is transferred
198 198 * each pass through this loop
199 199 */
200 200 bytes = MIN(PAGESIZE - pageoffset, uio->uio_resid);
201 201
202 202 if (offset + bytes >= limit) {
203 203 if (offset >= limit) {
204 204 error = EFBIG;
205 205 goto out;
206 206 }
207 207 bytes = limit - offset;
208 208 }
209 209 pagenumber = btop(offset);
210 210
211 211 /*
212 212 * delta is the amount of anonymous memory
213 213 * to reserve for the file.
214 214 * We always reserve in pagesize increments so
215 215 * unless we're extending the file into a new page,
216 216 * we don't need to call tmp_resv.
217 217 */
218 218 delta = offset + bytes -
219 219 P2ROUNDUP_TYPED(tp->tn_size, PAGESIZE, u_offset_t);
220 220 if (delta > 0) {
221 221 pagecreate = 1;
222 222 if (tmp_resv(tm, tp, delta, pagecreate)) {
223 223 /*
224 224 * Log file system full in the zone that owns
225 225 * the tmpfs mount, as well as in the global
226 226 * zone if necessary.
227 227 */
228 228 zcmn_err(tm->tm_vfsp->vfs_zone->zone_id,
229 229 CE_WARN, "%s: File system full, "
230 230 "swap space limit exceeded",
231 231 tm->tm_mntpath);
232 232
233 233 if (tm->tm_vfsp->vfs_zone->zone_id !=
234 234 GLOBAL_ZONEID) {
235 235
236 236 vfs_t *vfs = tm->tm_vfsp;
237 237
238 238 zcmn_err(GLOBAL_ZONEID,
239 239 CE_WARN, "%s: File system full, "
240 240 "swap space limit exceeded",
241 241 vfs->vfs_vnodecovered->v_path);
242 242 }
243 243 error = ENOSPC;
244 244 break;
245 245 }
246 246 tmpnode_growmap(tp, (ulong_t)offset + bytes);
247 247 }
248 248 /* grow the file to the new length */
249 249 if (offset + bytes > tp->tn_size) {
250 250 tn_size_changed = 1;
251 251 old_tn_size = tp->tn_size;
252 252 /*
253 253 * Postpone updating tp->tn_size until uiomove() is
254 254 * done.
255 255 */
256 256 new_tn_size = offset + bytes;
257 257 }
258 258 if (bytes == PAGESIZE) {
259 259 /*
260 260 * Writing whole page so reading from disk
261 261 * is a waste
262 262 */
263 263 pagecreate = 1;
264 264 } else {
265 265 pagecreate = 0;
266 266 }
267 267 /*
268 268 * If writing past EOF or filling in a hole
269 269 * we need to allocate an anon slot.
270 270 */
271 271 if (anon_get_ptr(tp->tn_anon, pagenumber) == NULL) {
272 272 (void) anon_set_ptr(tp->tn_anon, pagenumber,
273 273 anon_alloc(vp, ptob(pagenumber)), ANON_SLEEP);
274 274 pagecreate = 1;
275 275 tp->tn_nblocks++;
276 276 }
277 277
278 278 /*
279 279 * We have to drop the contents lock to allow the VM
280 280 * system to reacquire it in tmp_getpage()
281 281 */
282 282 rw_exit(&tp->tn_contents);
283 283
284 284 /*
285 285 * Touch the page and fault it in if it is not in core
286 286 * before segmap_getmapflt or vpm_data_copy can lock it.
287 287 * This is to avoid the deadlock if the buffer is mapped
288 288 * to the same file through mmap which we want to write.
289 289 */
290 290 uio_prefaultpages((long)bytes, uio);
291 291
292 292 newpage = 0;
293 293 if (vpm_enable) {
294 294 /*
295 295 * Copy data. If new pages are created, part of
296 296 * the page that is not written will be initizliazed
297 297 * with zeros.
298 298 */
299 299 error = vpm_data_copy(vp, offset, bytes, uio,
300 300 !pagecreate, &newpage, 1, S_WRITE);
301 301 } else {
302 302 /* Get offset within the segmap mapping */
303 303 segmap_offset = (offset & PAGEMASK) & MAXBOFFSET;
304 304 base = segmap_getmapflt(segkmap, vp,
305 305 (offset & MAXBMASK), PAGESIZE, !pagecreate,
306 306 S_WRITE);
307 307 }
308 308
309 309
310 310 if (!vpm_enable && pagecreate) {
311 311 /*
312 312 * segmap_pagecreate() returns 1 if it calls
313 313 * page_create_va() to allocate any pages.
314 314 */
315 315 newpage = segmap_pagecreate(segkmap,
316 316 base + segmap_offset, (size_t)PAGESIZE, 0);
317 317 /*
318 318 * Clear from the beginning of the page to the starting
319 319 * offset of the data.
320 320 */
321 321 if (pageoffset != 0)
322 322 (void) kzero(base + segmap_offset,
323 323 (size_t)pageoffset);
324 324 }
325 325
326 326 if (!vpm_enable) {
327 327 error = uiomove(base + segmap_offset + pageoffset,
328 328 (long)bytes, UIO_WRITE, uio);
329 329 }
330 330
331 331 if (!vpm_enable && pagecreate &&
332 332 uio->uio_offset < P2ROUNDUP(offset + bytes, PAGESIZE)) {
333 333 long zoffset; /* zero from offset into page */
334 334 /*
335 335 * We created pages w/o initializing them completely,
336 336 * thus we need to zero the part that wasn't set up.
337 337 * This happens on most EOF write cases and if
338 338 * we had some sort of error during the uiomove.
339 339 */
340 340 long nmoved;
341 341
342 342 nmoved = uio->uio_offset - offset;
343 343 ASSERT((nmoved + pageoffset) <= PAGESIZE);
344 344
345 345 /*
346 346 * Zero from the end of data in the page to the
347 347 * end of the page.
348 348 */
349 349 if ((zoffset = pageoffset + nmoved) < PAGESIZE)
350 350 (void) kzero(base + segmap_offset + zoffset,
351 351 (size_t)PAGESIZE - zoffset);
352 352 }
353 353
354 354 /*
355 355 * Unlock the pages which have been allocated by
356 356 * page_create_va() in segmap_pagecreate()
357 357 */
358 358 if (!vpm_enable && newpage) {
359 359 segmap_pageunlock(segkmap, base + segmap_offset,
360 360 (size_t)PAGESIZE, S_WRITE);
361 361 }
362 362
363 363 if (error) {
364 364 /*
365 365 * If we failed on a write, we must
366 366 * be sure to invalidate any pages that may have
367 367 * been allocated.
368 368 */
369 369 if (vpm_enable) {
370 370 (void) vpm_sync_pages(vp, offset, PAGESIZE,
371 371 SM_INVAL);
372 372 } else {
373 373 (void) segmap_release(segkmap, base, SM_INVAL);
374 374 }
375 375 } else {
376 376 if (vpm_enable) {
377 377 error = vpm_sync_pages(vp, offset, PAGESIZE,
378 378 0);
379 379 } else {
380 380 error = segmap_release(segkmap, base, 0);
381 381 }
382 382 }
383 383
384 384 /*
385 385 * Re-acquire contents lock.
386 386 */
387 387 rw_enter(&tp->tn_contents, RW_WRITER);
388 388
389 389 /*
390 390 * Update tn_size.
391 391 */
392 392 if (tn_size_changed)
393 393 tp->tn_size = new_tn_size;
394 394
395 395 /*
396 396 * If the uiomove failed, fix up tn_size.
397 397 */
398 398 if (error) {
399 399 if (tn_size_changed) {
400 400 /*
401 401 * The uiomove failed, and we
402 402 * allocated blocks,so get rid
403 403 * of them.
404 404 */
405 405 (void) tmpnode_trunc(tm, tp,
406 406 (ulong_t)old_tn_size);
407 407 }
408 408 } else {
409 409 /*
410 410 * XXX - Can this be out of the loop?
411 411 */
412 412 if ((tp->tn_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) &&
413 413 (tp->tn_mode & (S_ISUID | S_ISGID)) &&
414 414 secpolicy_vnode_setid_retain(cr,
415 415 (tp->tn_mode & S_ISUID) != 0 && tp->tn_uid == 0)) {
416 416 /*
417 417 * Clear Set-UID & Set-GID bits on
418 418 * successful write if not privileged
419 419 * and at least one of the execute bits
420 420 * is set. If we always clear Set-GID,
421 421 * mandatory file and record locking is
422 422 * unuseable.
423 423 */
424 424 tp->tn_mode &= ~(S_ISUID | S_ISGID);
425 425 }
426 426 gethrestime(&now);
427 427 tp->tn_mtime = now;
428 428 tp->tn_ctime = now;
429 429 }
430 430 } while (error == 0 && uio->uio_resid > 0 && bytes != 0);
431 431
432 432 out:
433 433 /*
434 434 * If we've already done a partial-write, terminate
435 435 * the write but return no error.
436 436 */
437 437 if (oresid != uio->uio_resid)
438 438 error = 0;
439 439 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
440 440 "tmp_wrtmp_end:vp %p error %d", vp, error);
441 441 return (error);
442 442 }
443 443
444 444 /*
445 445 * rdtmp does the real work of read requests for tmpfs.
446 446 */
447 447 static int
448 448 rdtmp(
449 449 struct tmount *tm,
450 450 struct tmpnode *tp,
451 451 struct uio *uio,
452 452 struct caller_context *ct)
453 453 {
454 454 ulong_t pageoffset; /* offset in tmpfs file (uio_offset) */
455 455 ulong_t segmap_offset; /* pagesize byte offset into segmap */
456 456 caddr_t base; /* base of segmap */
457 457 ssize_t bytes; /* bytes to uiomove */
458 458 struct vnode *vp;
459 459 int error;
460 460 long oresid = uio->uio_resid;
461 461
462 462 #if defined(lint)
463 463 tm = tm;
464 464 #endif
465 465 vp = TNTOV(tp);
466 466
467 467 TRACE_1(TR_FAC_TMPFS, TR_TMPFS_RWTMP_START, "tmp_rdtmp_start:vp %p",
468 468 vp);
469 469
470 470 ASSERT(RW_LOCK_HELD(&tp->tn_contents));
471 471
472 472 if (MANDLOCK(vp, tp->tn_mode)) {
473 473 rw_exit(&tp->tn_contents);
474 474 /*
475 475 * tmp_getattr ends up being called by chklock
476 476 */
477 477 error = chklock(vp, FREAD, uio->uio_loffset, uio->uio_resid,
478 478 uio->uio_fmode, ct);
479 479 rw_enter(&tp->tn_contents, RW_READER);
480 480 if (error != 0) {
481 481 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
482 482 "tmp_rdtmp_end:vp %p error %d", vp, error);
483 483 return (error);
484 484 }
485 485 }
486 486 ASSERT(tp->tn_type == VREG);
487 487
488 488 if (uio->uio_loffset >= MAXOFF_T) {
489 489 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
490 490 "tmp_rdtmp_end:vp %p error %d", vp, EINVAL);
491 491 return (0);
492 492 }
493 493 if (uio->uio_loffset < 0)
494 494 return (EINVAL);
495 495 if (uio->uio_resid == 0) {
496 496 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
497 497 "tmp_rdtmp_end:vp %p error %d", vp, 0);
498 498 return (0);
499 499 }
500 500
501 501 vp = TNTOV(tp);
502 502
503 503 do {
504 504 long diff;
505 505 long offset;
506 506
507 507 offset = uio->uio_offset;
508 508 pageoffset = offset & PAGEOFFSET;
509 509 bytes = MIN(PAGESIZE - pageoffset, uio->uio_resid);
510 510
511 511 diff = tp->tn_size - offset;
512 512
513 513 if (diff <= 0) {
514 514 error = 0;
515 515 goto out;
516 516 }
517 517 if (diff < bytes)
518 518 bytes = diff;
519 519
520 520 /*
521 521 * We have to drop the contents lock to allow the VM system
522 522 * to reacquire it in tmp_getpage() should the uiomove cause a
523 523 * pagefault.
524 524 */
525 525 rw_exit(&tp->tn_contents);
526 526
527 527 if (vpm_enable) {
528 528 /*
529 529 * Copy data.
530 530 */
531 531 error = vpm_data_copy(vp, offset, bytes, uio, 1, NULL,
532 532 0, S_READ);
533 533 } else {
534 534 segmap_offset = (offset & PAGEMASK) & MAXBOFFSET;
535 535 base = segmap_getmapflt(segkmap, vp, offset & MAXBMASK,
536 536 bytes, 1, S_READ);
537 537
538 538 error = uiomove(base + segmap_offset + pageoffset,
539 539 (long)bytes, UIO_READ, uio);
540 540 }
541 541
542 542 if (error) {
543 543 if (vpm_enable) {
544 544 (void) vpm_sync_pages(vp, offset, PAGESIZE, 0);
545 545 } else {
546 546 (void) segmap_release(segkmap, base, 0);
547 547 }
548 548 } else {
549 549 if (vpm_enable) {
550 550 error = vpm_sync_pages(vp, offset, PAGESIZE,
551 551 0);
552 552 } else {
553 553 error = segmap_release(segkmap, base, 0);
554 554 }
555 555 }
556 556
557 557 /*
558 558 * Re-acquire contents lock.
559 559 */
560 560 rw_enter(&tp->tn_contents, RW_READER);
561 561
562 562 } while (error == 0 && uio->uio_resid > 0);
563 563
564 564 out:
565 565 gethrestime(&tp->tn_atime);
566 566
567 567 /*
568 568 * If we've already done a partial read, terminate
569 569 * the read but return no error.
570 570 */
571 571 if (oresid != uio->uio_resid)
572 572 error = 0;
573 573
574 574 TRACE_2(TR_FAC_TMPFS, TR_TMPFS_RWTMP_END,
575 575 "tmp_rdtmp_end:vp %x error %d", vp, error);
576 576 return (error);
577 577 }
|
↓ open down ↓ |
539 lines elided |
↑ open up ↑ |
578 578
579 579 /* ARGSUSED2 */
580 580 static int
581 581 tmp_read(struct vnode *vp, struct uio *uiop, int ioflag, cred_t *cred,
582 582 struct caller_context *ct)
583 583 {
584 584 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
585 585 struct tmount *tm = (struct tmount *)VTOTM(vp);
586 586 int error;
587 587
588 - /* If the filesystem was umounted by force, return immediately. */
589 - if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
590 - return (EIO);
591 -
592 588 /*
593 589 * We don't currently support reading non-regular files
594 590 */
595 591 if (vp->v_type == VDIR)
596 592 return (EISDIR);
597 593 if (vp->v_type != VREG)
598 594 return (EINVAL);
599 595 /*
600 596 * tmp_rwlock should have already been called from layers above
601 597 */
602 598 ASSERT(RW_READ_HELD(&tp->tn_rwlock));
603 599
604 600 rw_enter(&tp->tn_contents, RW_READER);
605 601
606 602 error = rdtmp(tm, tp, uiop, ct);
607 603
608 604 rw_exit(&tp->tn_contents);
609 605
610 606 return (error);
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
611 607 }
612 608
613 609 static int
614 610 tmp_write(struct vnode *vp, struct uio *uiop, int ioflag, struct cred *cred,
615 611 struct caller_context *ct)
616 612 {
617 613 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
618 614 struct tmount *tm = (struct tmount *)VTOTM(vp);
619 615 int error;
620 616
621 - /* If the filesystem was umounted by force, return immediately. */
622 - if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
623 - return (EIO);
624 -
625 617 /*
626 618 * We don't currently support writing to non-regular files
627 619 */
628 620 if (vp->v_type != VREG)
629 621 return (EINVAL); /* XXX EISDIR? */
630 622
631 623 /*
632 624 * tmp_rwlock should have already been called from layers above
633 625 */
634 626 ASSERT(RW_WRITE_HELD(&tp->tn_rwlock));
635 627
636 628 rw_enter(&tp->tn_contents, RW_WRITER);
637 629
638 630 if (ioflag & FAPPEND) {
639 631 /*
640 632 * In append mode start at end of file.
641 633 */
642 634 uiop->uio_loffset = tp->tn_size;
643 635 }
644 636
645 637 error = wrtmp(tm, tp, uiop, cred, ct);
646 638
647 639 rw_exit(&tp->tn_contents);
648 640
649 641 return (error);
650 642 }
651 643
652 644 /* ARGSUSED */
653 645 static int
654 646 tmp_ioctl(
655 647 struct vnode *vp,
656 648 int com,
657 649 intptr_t data,
658 650 int flag,
659 651 struct cred *cred,
660 652 int *rvalp,
661 653 caller_context_t *ct)
662 654 {
663 655 return (ENOTTY);
664 656 }
665 657
666 658 /* ARGSUSED2 */
667 659 static int
668 660 tmp_getattr(
669 661 struct vnode *vp,
670 662 struct vattr *vap,
671 663 int flags,
672 664 struct cred *cred,
673 665 caller_context_t *ct)
674 666 {
675 667 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
676 668 struct vnode *mvp;
677 669 struct vattr va;
678 670 int attrs = 1;
679 671
680 672 /*
681 673 * A special case to handle the root tnode on a diskless nfs
682 674 * client who may have had its uid and gid inherited
683 675 * from an nfs vnode with nobody ownership. Likely the
684 676 * root filesystem. After nfs is fully functional the uid/gid
685 677 * may be mapable so ask again.
686 678 * vfsp can't get unmounted because we hold vp.
687 679 */
688 680 if (vp->v_flag & VROOT &&
689 681 (mvp = vp->v_vfsp->vfs_vnodecovered) != NULL) {
690 682 mutex_enter(&tp->tn_tlock);
691 683 if (tp->tn_uid == UID_NOBODY || tp->tn_gid == GID_NOBODY) {
692 684 mutex_exit(&tp->tn_tlock);
693 685 bzero(&va, sizeof (struct vattr));
694 686 va.va_mask = AT_UID|AT_GID;
695 687 attrs = VOP_GETATTR(mvp, &va, 0, cred, ct);
696 688 } else {
697 689 mutex_exit(&tp->tn_tlock);
698 690 }
699 691 }
700 692 mutex_enter(&tp->tn_tlock);
701 693 if (attrs == 0) {
702 694 tp->tn_uid = va.va_uid;
703 695 tp->tn_gid = va.va_gid;
704 696 }
705 697 vap->va_type = vp->v_type;
706 698 vap->va_mode = tp->tn_mode & MODEMASK;
707 699 vap->va_uid = tp->tn_uid;
708 700 vap->va_gid = tp->tn_gid;
709 701 vap->va_fsid = tp->tn_fsid;
710 702 vap->va_nodeid = (ino64_t)tp->tn_nodeid;
711 703 vap->va_nlink = tp->tn_nlink;
712 704 vap->va_size = (u_offset_t)tp->tn_size;
713 705 vap->va_atime = tp->tn_atime;
714 706 vap->va_mtime = tp->tn_mtime;
715 707 vap->va_ctime = tp->tn_ctime;
716 708 vap->va_blksize = PAGESIZE;
717 709 vap->va_rdev = tp->tn_rdev;
718 710 vap->va_seq = tp->tn_seq;
719 711
720 712 /*
721 713 * XXX Holes are not taken into account. We could take the time to
722 714 * run through the anon array looking for allocated slots...
723 715 */
724 716 vap->va_nblocks = (fsblkcnt64_t)btodb(ptob(btopr(vap->va_size)));
725 717 mutex_exit(&tp->tn_tlock);
726 718 return (0);
727 719 }
728 720
729 721 /*ARGSUSED4*/
730 722 static int
731 723 tmp_setattr(
732 724 struct vnode *vp,
733 725 struct vattr *vap,
734 726 int flags,
735 727 struct cred *cred,
736 728 caller_context_t *ct)
737 729 {
738 730 struct tmount *tm = (struct tmount *)VTOTM(vp);
739 731 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
740 732 int error = 0;
741 733 struct vattr *get;
742 734 long mask;
743 735
744 736 /*
745 737 * Cannot set these attributes
746 738 */
747 739 if ((vap->va_mask & AT_NOSET) || (vap->va_mask & AT_XVATTR))
748 740 return (EINVAL);
749 741
750 742 mutex_enter(&tp->tn_tlock);
751 743
752 744 get = &tp->tn_attr;
753 745 /*
754 746 * Change file access modes. Must be owner or have sufficient
755 747 * privileges.
756 748 */
757 749 error = secpolicy_vnode_setattr(cred, vp, vap, get, flags, tmp_taccess,
758 750 tp);
759 751
760 752 if (error)
761 753 goto out;
762 754
763 755 mask = vap->va_mask;
764 756
765 757 if (mask & AT_MODE) {
766 758 get->va_mode &= S_IFMT;
767 759 get->va_mode |= vap->va_mode & ~S_IFMT;
768 760 }
769 761
770 762 if (mask & AT_UID)
771 763 get->va_uid = vap->va_uid;
772 764 if (mask & AT_GID)
773 765 get->va_gid = vap->va_gid;
774 766 if (mask & AT_ATIME)
775 767 get->va_atime = vap->va_atime;
776 768 if (mask & AT_MTIME)
777 769 get->va_mtime = vap->va_mtime;
778 770
779 771 if (mask & (AT_UID | AT_GID | AT_MODE | AT_MTIME))
780 772 gethrestime(&tp->tn_ctime);
781 773
782 774 if (mask & AT_SIZE) {
783 775 ASSERT(vp->v_type != VDIR);
784 776
785 777 /* Don't support large files. */
786 778 if (vap->va_size > MAXOFF_T) {
787 779 error = EFBIG;
788 780 goto out;
789 781 }
790 782 mutex_exit(&tp->tn_tlock);
791 783
792 784 rw_enter(&tp->tn_rwlock, RW_WRITER);
793 785 rw_enter(&tp->tn_contents, RW_WRITER);
794 786 error = tmpnode_trunc(tm, tp, (ulong_t)vap->va_size);
795 787 rw_exit(&tp->tn_contents);
796 788 rw_exit(&tp->tn_rwlock);
797 789
798 790 if (error == 0) {
799 791 if (vap->va_size == 0) {
800 792 vnevent_truncate(vp, ct);
801 793 } else {
802 794 vnevent_resize(vp, ct);
803 795 }
804 796 }
805 797
806 798 goto out1;
807 799 }
808 800 out:
809 801 mutex_exit(&tp->tn_tlock);
810 802 out1:
811 803 return (error);
812 804 }
813 805
814 806 /* ARGSUSED2 */
815 807 static int
816 808 tmp_access(
817 809 struct vnode *vp,
818 810 int mode,
819 811 int flags,
820 812 struct cred *cred,
821 813 caller_context_t *ct)
822 814 {
823 815 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
824 816 int error;
825 817
826 818 mutex_enter(&tp->tn_tlock);
827 819 error = tmp_taccess(tp, mode, cred);
828 820 mutex_exit(&tp->tn_tlock);
829 821 return (error);
830 822 }
831 823
832 824 /* ARGSUSED3 */
833 825 static int
834 826 tmp_lookup(
835 827 struct vnode *dvp,
836 828 char *nm,
837 829 struct vnode **vpp,
838 830 struct pathname *pnp,
839 831 int flags,
|
↓ open down ↓ |
205 lines elided |
↑ open up ↑ |
840 832 struct vnode *rdir,
841 833 struct cred *cred,
842 834 caller_context_t *ct,
843 835 int *direntflags,
844 836 pathname_t *realpnp)
845 837 {
846 838 struct tmpnode *tp = (struct tmpnode *)VTOTN(dvp);
847 839 struct tmpnode *ntp = NULL;
848 840 int error;
849 841
850 - /* If the filesystem was umounted by force, return immediately. */
851 - if (dvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
852 - return (EIO);
853 842
854 843 /* allow cd into @ dir */
855 844 if (flags & LOOKUP_XATTR) {
856 845 struct tmpnode *xdp;
857 846 struct tmount *tm;
858 847
859 848 /*
860 849 * don't allow attributes if not mounted XATTR support
861 850 */
862 851 if (!(dvp->v_vfsp->vfs_flag & VFS_XATTR))
863 852 return (EINVAL);
864 853
865 854 if (tp->tn_flags & ISXATTR)
866 855 /* No attributes on attributes */
867 856 return (EINVAL);
868 857
869 858 rw_enter(&tp->tn_rwlock, RW_WRITER);
870 859 if (tp->tn_xattrdp == NULL) {
871 - int err;
872 -
873 860 if (!(flags & CREATE_XATTR_DIR)) {
874 861 rw_exit(&tp->tn_rwlock);
875 862 return (ENOENT);
876 863 }
877 864
878 865 /*
879 866 * No attribute directory exists for this
880 867 * node - create the attr dir as a side effect
881 868 * of this lookup.
882 869 */
883 870
884 871 /*
885 872 * Make sure we have adequate permission...
886 873 */
887 874
888 875 if ((error = tmp_taccess(tp, VWRITE, cred)) != 0) {
889 876 rw_exit(&tp->tn_rwlock);
890 877 return (error);
891 878 }
892 879
880 + xdp = tmp_memalloc(sizeof (struct tmpnode),
881 + TMP_MUSTHAVE);
893 882 tm = VTOTM(dvp);
894 - xdp = tmp_kmem_zalloc(tm, sizeof (struct tmpnode),
895 - KM_SLEEP);
896 - if (xdp == NULL) {
897 - rw_exit(&tp->tn_rwlock);
898 - return (ENOSPC);
899 - }
900 883 tmpnode_init(tm, xdp, &tp->tn_attr, NULL);
901 884 /*
902 885 * Fix-up fields unique to attribute directories.
903 886 */
904 887 xdp->tn_flags = ISXATTR;
905 888 xdp->tn_type = VDIR;
906 889 if (tp->tn_type == VDIR) {
907 890 xdp->tn_mode = tp->tn_attr.va_mode;
908 891 } else {
909 892 xdp->tn_mode = 0700;
910 893 if (tp->tn_attr.va_mode & 0040)
911 894 xdp->tn_mode |= 0750;
912 895 if (tp->tn_attr.va_mode & 0004)
913 896 xdp->tn_mode |= 0705;
914 897 }
915 898 xdp->tn_vnode->v_type = VDIR;
916 899 xdp->tn_vnode->v_flag |= V_XATTRDIR;
917 - if ((err = tdirinit(tp, xdp)) != 0) {
918 - rw_exit(&tp->tn_rwlock);
919 - /*
920 - * This never got properly initialized so we can
921 - * just clean it up.
922 - */
923 - xdp->tn_vnode->v_flag &= V_XATTRDIR;
924 - tmpnode_cleanup(tp);
925 - return (err);
926 - }
900 + tdirinit(tp, xdp);
927 901 tp->tn_xattrdp = xdp;
928 902 } else {
929 903 VN_HOLD(tp->tn_xattrdp->tn_vnode);
930 904 }
931 905 *vpp = TNTOV(tp->tn_xattrdp);
932 906 rw_exit(&tp->tn_rwlock);
933 907 return (0);
934 908 }
935 909
936 910 /*
937 911 * Null component name is a synonym for directory being searched.
938 912 */
939 913 if (*nm == '\0') {
940 914 VN_HOLD(dvp);
941 915 *vpp = dvp;
942 916 return (0);
943 917 }
944 918 ASSERT(tp);
945 919
946 920 error = tdirlookup(tp, nm, &ntp, cred);
947 921
948 922 if (error == 0) {
949 923 ASSERT(ntp);
950 924 *vpp = TNTOV(ntp);
951 925 /*
952 926 * If vnode is a device return special vnode instead
953 927 */
954 928 if (IS_DEVVP(*vpp)) {
955 929 struct vnode *newvp;
956 930
957 931 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type,
958 932 cred);
959 933 VN_RELE(*vpp);
960 934 *vpp = newvp;
961 935 }
962 936 }
963 937 TRACE_4(TR_FAC_TMPFS, TR_TMPFS_LOOKUP,
964 938 "tmpfs lookup:vp %p name %s vpp %p error %d",
965 939 dvp, nm, vpp, error);
966 940 return (error);
967 941 }
968 942
969 943 /*ARGSUSED7*/
970 944 static int
971 945 tmp_create(
972 946 struct vnode *dvp,
973 947 char *nm,
974 948 struct vattr *vap,
975 949 enum vcexcl exclusive,
976 950 int mode,
977 951 struct vnode **vpp,
978 952 struct cred *cred,
979 953 int flag,
980 954 caller_context_t *ct,
981 955 vsecattr_t *vsecp)
982 956 {
983 957 struct tmpnode *parent;
984 958 struct tmount *tm;
985 959 struct tmpnode *self;
986 960 int error;
987 961 struct tmpnode *oldtp;
988 962
989 963 again:
990 964 parent = (struct tmpnode *)VTOTN(dvp);
991 965 tm = (struct tmount *)VTOTM(dvp);
992 966 self = NULL;
993 967 error = 0;
994 968 oldtp = NULL;
995 969
996 970 /* device files not allowed in ext. attr dirs */
997 971 if ((parent->tn_flags & ISXATTR) &&
998 972 (vap->va_type == VBLK || vap->va_type == VCHR ||
999 973 vap->va_type == VFIFO || vap->va_type == VDOOR ||
1000 974 vap->va_type == VSOCK || vap->va_type == VPORT))
1001 975 return (EINVAL);
1002 976
1003 977 if (vap->va_type == VREG && (vap->va_mode & VSVTX)) {
1004 978 /* Must be privileged to set sticky bit */
1005 979 if (secpolicy_vnode_stky_modify(cred))
1006 980 vap->va_mode &= ~VSVTX;
1007 981 } else if (vap->va_type == VNON) {
1008 982 return (EINVAL);
1009 983 }
1010 984
1011 985 /*
1012 986 * Null component name is a synonym for directory being searched.
1013 987 */
1014 988 if (*nm == '\0') {
1015 989 VN_HOLD(dvp);
1016 990 oldtp = parent;
1017 991 } else {
1018 992 error = tdirlookup(parent, nm, &oldtp, cred);
1019 993 }
1020 994
1021 995 if (error == 0) { /* name found */
1022 996 boolean_t trunc = B_FALSE;
1023 997
1024 998 ASSERT(oldtp);
1025 999
1026 1000 rw_enter(&oldtp->tn_rwlock, RW_WRITER);
1027 1001
1028 1002 /*
1029 1003 * if create/read-only an existing
1030 1004 * directory, allow it
1031 1005 */
1032 1006 if (exclusive == EXCL)
1033 1007 error = EEXIST;
1034 1008 else if ((oldtp->tn_type == VDIR) && (mode & VWRITE))
1035 1009 error = EISDIR;
1036 1010 else {
1037 1011 error = tmp_taccess(oldtp, mode, cred);
1038 1012 }
1039 1013
1040 1014 if (error) {
1041 1015 rw_exit(&oldtp->tn_rwlock);
1042 1016 tmpnode_rele(oldtp);
1043 1017 return (error);
1044 1018 }
1045 1019 *vpp = TNTOV(oldtp);
1046 1020 if ((*vpp)->v_type == VREG && (vap->va_mask & AT_SIZE) &&
1047 1021 vap->va_size == 0) {
1048 1022 rw_enter(&oldtp->tn_contents, RW_WRITER);
1049 1023 (void) tmpnode_trunc(tm, oldtp, 0);
1050 1024 rw_exit(&oldtp->tn_contents);
1051 1025 trunc = B_TRUE;
1052 1026 }
1053 1027 rw_exit(&oldtp->tn_rwlock);
1054 1028 if (IS_DEVVP(*vpp)) {
1055 1029 struct vnode *newvp;
1056 1030
1057 1031 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type,
1058 1032 cred);
1059 1033 VN_RELE(*vpp);
1060 1034 if (newvp == NULL) {
1061 1035 return (ENOSYS);
1062 1036 }
1063 1037 *vpp = newvp;
1064 1038 }
1065 1039
1066 1040 if (trunc)
1067 1041 vnevent_create(*vpp, ct);
1068 1042
1069 1043 return (0);
1070 1044 }
1071 1045
1072 1046 if (error != ENOENT)
1073 1047 return (error);
1074 1048
1075 1049 rw_enter(&parent->tn_rwlock, RW_WRITER);
1076 1050 error = tdirenter(tm, parent, nm, DE_CREATE,
1077 1051 (struct tmpnode *)NULL, (struct tmpnode *)NULL,
1078 1052 vap, &self, cred, ct);
1079 1053 rw_exit(&parent->tn_rwlock);
1080 1054
1081 1055 if (error) {
1082 1056 if (self)
1083 1057 tmpnode_rele(self);
1084 1058
1085 1059 if (error == EEXIST) {
1086 1060 /*
1087 1061 * This means that the file was created sometime
1088 1062 * after we checked and did not find it and when
1089 1063 * we went to create it.
1090 1064 * Since creat() is supposed to truncate a file
1091 1065 * that already exits go back to the begining
1092 1066 * of the function. This time we will find it
1093 1067 * and go down the tmp_trunc() path
1094 1068 */
1095 1069 goto again;
1096 1070 }
1097 1071 return (error);
1098 1072 }
1099 1073
1100 1074 *vpp = TNTOV(self);
1101 1075
1102 1076 if (!error && IS_DEVVP(*vpp)) {
1103 1077 struct vnode *newvp;
1104 1078
1105 1079 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cred);
1106 1080 VN_RELE(*vpp);
1107 1081 if (newvp == NULL)
1108 1082 return (ENOSYS);
1109 1083 *vpp = newvp;
1110 1084 }
1111 1085 TRACE_3(TR_FAC_TMPFS, TR_TMPFS_CREATE,
1112 1086 "tmpfs create:dvp %p nm %s vpp %p", dvp, nm, vpp);
1113 1087 return (0);
1114 1088 }
1115 1089
1116 1090 /* ARGSUSED3 */
1117 1091 static int
1118 1092 tmp_remove(
1119 1093 struct vnode *dvp,
1120 1094 char *nm,
1121 1095 struct cred *cred,
1122 1096 caller_context_t *ct,
1123 1097 int flags)
1124 1098 {
1125 1099 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1126 1100 int error;
1127 1101 struct tmpnode *tp = NULL;
1128 1102
1129 1103 error = tdirlookup(parent, nm, &tp, cred);
1130 1104 if (error)
1131 1105 return (error);
1132 1106
1133 1107 ASSERT(tp);
1134 1108 rw_enter(&parent->tn_rwlock, RW_WRITER);
1135 1109 rw_enter(&tp->tn_rwlock, RW_WRITER);
1136 1110
1137 1111 if (tp->tn_type != VDIR ||
1138 1112 (error = secpolicy_fs_linkdir(cred, dvp->v_vfsp)) == 0)
1139 1113 error = tdirdelete(parent, tp, nm, tp->tn_type == VDIR ?
1140 1114 DR_RMDIR : DR_REMOVE, cred);
1141 1115
1142 1116 rw_exit(&tp->tn_rwlock);
1143 1117 rw_exit(&parent->tn_rwlock);
1144 1118 vnevent_remove(TNTOV(tp), dvp, nm, ct);
1145 1119 tmpnode_rele(tp);
1146 1120
1147 1121 TRACE_3(TR_FAC_TMPFS, TR_TMPFS_REMOVE,
1148 1122 "tmpfs remove:dvp %p nm %s error %d", dvp, nm, error);
1149 1123 return (error);
1150 1124 }
1151 1125
1152 1126 /* ARGSUSED4 */
1153 1127 static int
1154 1128 tmp_link(
1155 1129 struct vnode *dvp,
1156 1130 struct vnode *srcvp,
1157 1131 char *tnm,
1158 1132 struct cred *cred,
1159 1133 caller_context_t *ct,
1160 1134 int flags)
1161 1135 {
1162 1136 struct tmpnode *parent;
1163 1137 struct tmpnode *from;
1164 1138 struct tmount *tm = (struct tmount *)VTOTM(dvp);
1165 1139 int error;
1166 1140 struct tmpnode *found = NULL;
1167 1141 struct vnode *realvp;
1168 1142
1169 1143 if (VOP_REALVP(srcvp, &realvp, ct) == 0)
1170 1144 srcvp = realvp;
1171 1145
1172 1146 parent = (struct tmpnode *)VTOTN(dvp);
1173 1147 from = (struct tmpnode *)VTOTN(srcvp);
1174 1148
1175 1149 if ((srcvp->v_type == VDIR &&
1176 1150 secpolicy_fs_linkdir(cred, dvp->v_vfsp)) ||
1177 1151 (from->tn_uid != crgetuid(cred) && secpolicy_basic_link(cred)))
1178 1152 return (EPERM);
1179 1153
1180 1154 /*
1181 1155 * Make sure link for extended attributes is valid
1182 1156 * We only support hard linking of xattr's in xattrdir to an xattrdir
1183 1157 */
1184 1158 if ((from->tn_flags & ISXATTR) != (parent->tn_flags & ISXATTR))
1185 1159 return (EINVAL);
1186 1160
1187 1161 error = tdirlookup(parent, tnm, &found, cred);
1188 1162 if (error == 0) {
1189 1163 ASSERT(found);
1190 1164 tmpnode_rele(found);
1191 1165 return (EEXIST);
1192 1166 }
1193 1167
1194 1168 if (error != ENOENT)
1195 1169 return (error);
1196 1170
1197 1171 rw_enter(&parent->tn_rwlock, RW_WRITER);
1198 1172 error = tdirenter(tm, parent, tnm, DE_LINK, (struct tmpnode *)NULL,
1199 1173 from, NULL, (struct tmpnode **)NULL, cred, ct);
1200 1174 rw_exit(&parent->tn_rwlock);
1201 1175 if (error == 0) {
1202 1176 vnevent_link(srcvp, ct);
1203 1177 }
1204 1178 return (error);
1205 1179 }
1206 1180
1207 1181 /* ARGSUSED5 */
1208 1182 static int
1209 1183 tmp_rename(
1210 1184 struct vnode *odvp, /* source parent vnode */
1211 1185 char *onm, /* source name */
1212 1186 struct vnode *ndvp, /* destination parent vnode */
1213 1187 char *nnm, /* destination name */
1214 1188 struct cred *cred,
1215 1189 caller_context_t *ct,
1216 1190 int flags)
1217 1191 {
1218 1192 struct tmpnode *fromparent;
1219 1193 struct tmpnode *toparent;
1220 1194 struct tmpnode *fromtp = NULL; /* source tmpnode */
1221 1195 struct tmpnode *totp; /* target tmpnode */
1222 1196 struct tmount *tm = (struct tmount *)VTOTM(odvp);
1223 1197 int error;
1224 1198 int samedir = 0; /* set if odvp == ndvp */
1225 1199 struct vnode *realvp;
1226 1200
1227 1201 if (VOP_REALVP(ndvp, &realvp, ct) == 0)
1228 1202 ndvp = realvp;
1229 1203
1230 1204 fromparent = (struct tmpnode *)VTOTN(odvp);
1231 1205 toparent = (struct tmpnode *)VTOTN(ndvp);
1232 1206
1233 1207 if ((fromparent->tn_flags & ISXATTR) != (toparent->tn_flags & ISXATTR))
1234 1208 return (EINVAL);
1235 1209
1236 1210 mutex_enter(&tm->tm_renamelck);
1237 1211
1238 1212 /*
1239 1213 * Look up tmpnode of file we're supposed to rename.
1240 1214 */
1241 1215 error = tdirlookup(fromparent, onm, &fromtp, cred);
1242 1216 if (error) {
1243 1217 mutex_exit(&tm->tm_renamelck);
1244 1218 return (error);
1245 1219 }
1246 1220
1247 1221 /*
1248 1222 * Make sure we can delete the old (source) entry. This
1249 1223 * requires write permission on the containing directory. If
1250 1224 * that directory is "sticky" it requires further checks.
1251 1225 */
1252 1226 if (((error = tmp_taccess(fromparent, VWRITE, cred)) != 0) ||
1253 1227 (error = tmp_sticky_remove_access(fromparent, fromtp, cred)) != 0)
1254 1228 goto done;
1255 1229
1256 1230 /*
1257 1231 * Check for renaming to or from '.' or '..' or that
1258 1232 * fromtp == fromparent
1259 1233 */
1260 1234 if ((onm[0] == '.' &&
1261 1235 (onm[1] == '\0' || (onm[1] == '.' && onm[2] == '\0'))) ||
1262 1236 (nnm[0] == '.' &&
1263 1237 (nnm[1] == '\0' || (nnm[1] == '.' && nnm[2] == '\0'))) ||
1264 1238 (fromparent == fromtp)) {
1265 1239 error = EINVAL;
1266 1240 goto done;
1267 1241 }
1268 1242
1269 1243 samedir = (fromparent == toparent);
1270 1244 /*
1271 1245 * Make sure we can search and rename into the new
1272 1246 * (destination) directory.
1273 1247 */
1274 1248 if (!samedir) {
1275 1249 error = tmp_taccess(toparent, VEXEC|VWRITE, cred);
1276 1250 if (error)
1277 1251 goto done;
1278 1252 }
1279 1253
1280 1254 if (tdirlookup(toparent, nnm, &totp, cred) == 0) {
1281 1255 vnevent_pre_rename_dest(TNTOV(totp), ndvp, nnm, ct);
1282 1256 tmpnode_rele(totp);
1283 1257 }
1284 1258
1285 1259 /* Notify the target dir. if not the same as the source dir. */
1286 1260 if (ndvp != odvp) {
1287 1261 vnevent_pre_rename_dest_dir(ndvp, TNTOV(fromtp), nnm, ct);
1288 1262 }
1289 1263
1290 1264 vnevent_pre_rename_src(TNTOV(fromtp), odvp, onm, ct);
1291 1265
1292 1266 /*
1293 1267 * Link source to new target
1294 1268 */
1295 1269 rw_enter(&toparent->tn_rwlock, RW_WRITER);
1296 1270 error = tdirenter(tm, toparent, nnm, DE_RENAME,
1297 1271 fromparent, fromtp, (struct vattr *)NULL,
1298 1272 (struct tmpnode **)NULL, cred, ct);
1299 1273 rw_exit(&toparent->tn_rwlock);
1300 1274
1301 1275 if (error) {
1302 1276 /*
1303 1277 * ESAME isn't really an error; it indicates that the
1304 1278 * operation should not be done because the source and target
1305 1279 * are the same file, but that no error should be reported.
1306 1280 */
1307 1281 if (error == ESAME)
1308 1282 error = 0;
1309 1283 goto done;
1310 1284 }
1311 1285
1312 1286 /*
1313 1287 * Unlink from source.
1314 1288 */
1315 1289 rw_enter(&fromparent->tn_rwlock, RW_WRITER);
1316 1290 rw_enter(&fromtp->tn_rwlock, RW_WRITER);
1317 1291
1318 1292 error = tdirdelete(fromparent, fromtp, onm, DR_RENAME, cred);
1319 1293
1320 1294 /*
1321 1295 * The following handles the case where our source tmpnode was
1322 1296 * removed before we got to it.
1323 1297 *
1324 1298 * XXX We should also cleanup properly in the case where tdirdelete
1325 1299 * fails for some other reason. Currently this case shouldn't happen.
1326 1300 * (see 1184991).
1327 1301 */
1328 1302 if (error == ENOENT)
1329 1303 error = 0;
1330 1304
1331 1305 rw_exit(&fromtp->tn_rwlock);
1332 1306 rw_exit(&fromparent->tn_rwlock);
1333 1307
1334 1308 if (error == 0) {
1335 1309 vnevent_rename_src(TNTOV(fromtp), odvp, onm, ct);
1336 1310 /*
1337 1311 * vnevent_rename_dest is called in tdirenter().
1338 1312 */
1339 1313 vnevent_rename_dest_dir(ndvp, TNTOV(fromtp), nnm, ct);
1340 1314 }
1341 1315
1342 1316 done:
1343 1317 tmpnode_rele(fromtp);
1344 1318 mutex_exit(&tm->tm_renamelck);
1345 1319
1346 1320 TRACE_5(TR_FAC_TMPFS, TR_TMPFS_RENAME,
1347 1321 "tmpfs rename:ovp %p onm %s nvp %p nnm %s error %d", odvp, onm,
1348 1322 ndvp, nnm, error);
1349 1323 return (error);
1350 1324 }
1351 1325
1352 1326 /* ARGSUSED5 */
1353 1327 static int
1354 1328 tmp_mkdir(
1355 1329 struct vnode *dvp,
1356 1330 char *nm,
1357 1331 struct vattr *va,
1358 1332 struct vnode **vpp,
1359 1333 struct cred *cred,
1360 1334 caller_context_t *ct,
1361 1335 int flags,
1362 1336 vsecattr_t *vsecp)
1363 1337 {
1364 1338 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1365 1339 struct tmpnode *self = NULL;
1366 1340 struct tmount *tm = (struct tmount *)VTOTM(dvp);
1367 1341 int error;
1368 1342
1369 1343 /* no new dirs allowed in xattr dirs */
1370 1344 if (parent->tn_flags & ISXATTR)
1371 1345 return (EINVAL);
1372 1346
1373 1347 /*
1374 1348 * Might be dangling directory. Catch it here,
1375 1349 * because a ENOENT return from tdirlookup() is
1376 1350 * an "o.k. return".
1377 1351 */
1378 1352 if (parent->tn_nlink == 0)
1379 1353 return (ENOENT);
1380 1354
1381 1355 error = tdirlookup(parent, nm, &self, cred);
1382 1356 if (error == 0) {
1383 1357 ASSERT(self);
1384 1358 tmpnode_rele(self);
1385 1359 return (EEXIST);
1386 1360 }
1387 1361 if (error != ENOENT)
1388 1362 return (error);
1389 1363
1390 1364 rw_enter(&parent->tn_rwlock, RW_WRITER);
1391 1365 error = tdirenter(tm, parent, nm, DE_MKDIR, (struct tmpnode *)NULL,
1392 1366 (struct tmpnode *)NULL, va, &self, cred, ct);
1393 1367 if (error) {
1394 1368 rw_exit(&parent->tn_rwlock);
1395 1369 if (self)
1396 1370 tmpnode_rele(self);
1397 1371 return (error);
1398 1372 }
1399 1373 rw_exit(&parent->tn_rwlock);
1400 1374 *vpp = TNTOV(self);
1401 1375 return (0);
1402 1376 }
1403 1377
1404 1378 /* ARGSUSED4 */
1405 1379 static int
1406 1380 tmp_rmdir(
1407 1381 struct vnode *dvp,
1408 1382 char *nm,
1409 1383 struct vnode *cdir,
1410 1384 struct cred *cred,
1411 1385 caller_context_t *ct,
1412 1386 int flags)
1413 1387 {
1414 1388 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1415 1389 struct tmpnode *self = NULL;
1416 1390 struct vnode *vp;
1417 1391 int error = 0;
1418 1392
1419 1393 /*
1420 1394 * Return error when removing . and ..
1421 1395 */
1422 1396 if (strcmp(nm, ".") == 0)
1423 1397 return (EINVAL);
1424 1398 if (strcmp(nm, "..") == 0)
1425 1399 return (EEXIST); /* Should be ENOTEMPTY */
1426 1400 error = tdirlookup(parent, nm, &self, cred);
1427 1401 if (error)
1428 1402 return (error);
1429 1403
1430 1404 rw_enter(&parent->tn_rwlock, RW_WRITER);
1431 1405 rw_enter(&self->tn_rwlock, RW_WRITER);
1432 1406
1433 1407 vp = TNTOV(self);
1434 1408 if (vp == dvp || vp == cdir) {
1435 1409 error = EINVAL;
1436 1410 goto done1;
1437 1411 }
1438 1412 if (self->tn_type != VDIR) {
1439 1413 error = ENOTDIR;
1440 1414 goto done1;
1441 1415 }
1442 1416
1443 1417 mutex_enter(&self->tn_tlock);
1444 1418 if (self->tn_nlink > 2) {
1445 1419 mutex_exit(&self->tn_tlock);
1446 1420 error = EEXIST;
1447 1421 goto done1;
1448 1422 }
1449 1423 mutex_exit(&self->tn_tlock);
1450 1424
1451 1425 if (vn_vfswlock(vp)) {
1452 1426 error = EBUSY;
1453 1427 goto done1;
1454 1428 }
1455 1429 if (vn_mountedvfs(vp) != NULL) {
1456 1430 error = EBUSY;
1457 1431 goto done;
1458 1432 }
1459 1433
1460 1434 /*
1461 1435 * Check for an empty directory
1462 1436 * i.e. only includes entries for "." and ".."
1463 1437 */
1464 1438 if (self->tn_dirents > 2) {
1465 1439 error = EEXIST; /* SIGH should be ENOTEMPTY */
1466 1440 /*
1467 1441 * Update atime because checking tn_dirents is logically
1468 1442 * equivalent to reading the directory
1469 1443 */
1470 1444 gethrestime(&self->tn_atime);
1471 1445 goto done;
1472 1446 }
1473 1447
1474 1448 error = tdirdelete(parent, self, nm, DR_RMDIR, cred);
1475 1449 done:
1476 1450 vn_vfsunlock(vp);
1477 1451 done1:
1478 1452 rw_exit(&self->tn_rwlock);
1479 1453 rw_exit(&parent->tn_rwlock);
1480 1454 vnevent_rmdir(TNTOV(self), dvp, nm, ct);
1481 1455 tmpnode_rele(self);
1482 1456
1483 1457 return (error);
1484 1458 }
1485 1459
1486 1460 /* ARGSUSED2 */
1487 1461 static int
1488 1462 tmp_readdir(
1489 1463 struct vnode *vp,
1490 1464 struct uio *uiop,
1491 1465 struct cred *cred,
1492 1466 int *eofp,
1493 1467 caller_context_t *ct,
1494 1468 int flags)
1495 1469 {
1496 1470 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1497 1471 struct tdirent *tdp;
|
↓ open down ↓ |
561 lines elided |
↑ open up ↑ |
1498 1472 int error = 0;
1499 1473 size_t namelen;
1500 1474 struct dirent64 *dp;
1501 1475 ulong_t offset;
1502 1476 ulong_t total_bytes_wanted;
1503 1477 long outcount = 0;
1504 1478 long bufsize;
1505 1479 int reclen;
1506 1480 caddr_t outbuf;
1507 1481
1508 - /* If the filesystem was umounted by force, return immediately. */
1509 - if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
1510 - return (EIO);
1511 -
1512 1482 if (uiop->uio_loffset >= MAXOFF_T) {
1513 1483 if (eofp)
1514 1484 *eofp = 1;
1515 1485 return (0);
1516 1486 }
1517 1487 /*
1518 1488 * assuming system call has already called tmp_rwlock
1519 1489 */
1520 1490 ASSERT(RW_READ_HELD(&tp->tn_rwlock));
1521 1491
1522 1492 if (uiop->uio_iovcnt != 1)
1523 1493 return (EINVAL);
1524 1494
1525 1495 if (vp->v_type != VDIR)
1526 1496 return (ENOTDIR);
1527 1497
1528 1498 /*
1529 1499 * There's a window here where someone could have removed
1530 1500 * all the entries in the directory after we put a hold on the
1531 1501 * vnode but before we grabbed the rwlock. Just return.
1532 1502 */
1533 1503 if (tp->tn_dir == NULL) {
1534 1504 if (tp->tn_nlink) {
1535 1505 panic("empty directory 0x%p", (void *)tp);
1536 1506 /*NOTREACHED*/
1537 1507 }
1538 1508 return (0);
1539 1509 }
1540 1510
1541 1511 /*
1542 1512 * Get space for multiple directory entries
1543 1513 */
1544 1514 total_bytes_wanted = uiop->uio_iov->iov_len;
1545 1515 bufsize = total_bytes_wanted + sizeof (struct dirent64);
1546 1516 outbuf = kmem_alloc(bufsize, KM_SLEEP);
1547 1517
1548 1518 dp = (struct dirent64 *)outbuf;
1549 1519
1550 1520
1551 1521 offset = 0;
1552 1522 tdp = tp->tn_dir;
1553 1523 while (tdp) {
1554 1524 namelen = strlen(tdp->td_name); /* no +1 needed */
1555 1525 offset = tdp->td_offset;
1556 1526 if (offset >= uiop->uio_offset) {
1557 1527 reclen = (int)DIRENT64_RECLEN(namelen);
1558 1528 if (outcount + reclen > total_bytes_wanted) {
1559 1529 if (!outcount)
1560 1530 /*
1561 1531 * Buffer too small for any entries.
1562 1532 */
1563 1533 error = EINVAL;
1564 1534 break;
1565 1535 }
1566 1536 ASSERT(tdp->td_tmpnode != NULL);
1567 1537
1568 1538 /* use strncpy(9f) to zero out uninitialized bytes */
1569 1539
1570 1540 (void) strncpy(dp->d_name, tdp->td_name,
1571 1541 DIRENT64_NAMELEN(reclen));
1572 1542 dp->d_reclen = (ushort_t)reclen;
1573 1543 dp->d_ino = (ino64_t)tdp->td_tmpnode->tn_nodeid;
1574 1544 dp->d_off = (offset_t)tdp->td_offset + 1;
1575 1545 dp = (struct dirent64 *)
1576 1546 ((uintptr_t)dp + dp->d_reclen);
1577 1547 outcount += reclen;
1578 1548 ASSERT(outcount <= bufsize);
1579 1549 }
1580 1550 tdp = tdp->td_next;
1581 1551 }
1582 1552
1583 1553 if (!error)
1584 1554 error = uiomove(outbuf, outcount, UIO_READ, uiop);
1585 1555
1586 1556 if (!error) {
1587 1557 /* If we reached the end of the list our offset */
1588 1558 /* should now be just past the end. */
1589 1559 if (!tdp) {
1590 1560 offset += 1;
1591 1561 if (eofp)
1592 1562 *eofp = 1;
1593 1563 } else if (eofp)
1594 1564 *eofp = 0;
1595 1565 uiop->uio_offset = offset;
1596 1566 }
1597 1567 gethrestime(&tp->tn_atime);
1598 1568 kmem_free(outbuf, bufsize);
1599 1569 return (error);
1600 1570 }
1601 1571
1602 1572 /* ARGSUSED5 */
1603 1573 static int
1604 1574 tmp_symlink(
1605 1575 struct vnode *dvp,
1606 1576 char *lnm,
1607 1577 struct vattr *tva,
1608 1578 char *tnm,
1609 1579 struct cred *cred,
1610 1580 caller_context_t *ct,
1611 1581 int flags)
1612 1582 {
1613 1583 struct tmpnode *parent = (struct tmpnode *)VTOTN(dvp);
1614 1584 struct tmpnode *self = (struct tmpnode *)NULL;
1615 1585 struct tmount *tm = (struct tmount *)VTOTM(dvp);
1616 1586 char *cp = NULL;
1617 1587 int error;
1618 1588 size_t len;
1619 1589
1620 1590 /* no symlinks allowed to files in xattr dirs */
1621 1591 if (parent->tn_flags & ISXATTR)
1622 1592 return (EINVAL);
1623 1593
1624 1594 error = tdirlookup(parent, lnm, &self, cred);
1625 1595 if (error == 0) {
1626 1596 /*
1627 1597 * The entry already exists
1628 1598 */
1629 1599 tmpnode_rele(self);
1630 1600 return (EEXIST); /* was 0 */
1631 1601 }
1632 1602
1633 1603 if (error != ENOENT) {
1634 1604 if (self != NULL)
|
↓ open down ↓ |
113 lines elided |
↑ open up ↑ |
1635 1605 tmpnode_rele(self);
1636 1606 return (error);
1637 1607 }
1638 1608
1639 1609 rw_enter(&parent->tn_rwlock, RW_WRITER);
1640 1610 error = tdirenter(tm, parent, lnm, DE_CREATE, (struct tmpnode *)NULL,
1641 1611 (struct tmpnode *)NULL, tva, &self, cred, ct);
1642 1612 rw_exit(&parent->tn_rwlock);
1643 1613
1644 1614 if (error) {
1645 - if (self != NULL)
1615 + if (self)
1646 1616 tmpnode_rele(self);
1647 1617 return (error);
1648 1618 }
1649 1619 len = strlen(tnm) + 1;
1650 - cp = tmp_kmem_zalloc(tm, len, KM_NOSLEEP | KM_NORMALPRI);
1620 + cp = tmp_memalloc(len, 0);
1651 1621 if (cp == NULL) {
1652 1622 tmpnode_rele(self);
1653 1623 return (ENOSPC);
1654 1624 }
1655 1625 (void) strcpy(cp, tnm);
1656 1626
1657 1627 self->tn_symlink = cp;
1658 1628 self->tn_size = len - 1;
1659 1629 tmpnode_rele(self);
1660 1630 return (error);
1661 1631 }
1662 1632
1663 1633 /* ARGSUSED2 */
1664 1634 static int
1665 1635 tmp_readlink(
1666 1636 struct vnode *vp,
1667 1637 struct uio *uiop,
1668 1638 struct cred *cred,
1669 1639 caller_context_t *ct)
1670 1640 {
1671 1641 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1672 1642 int error = 0;
1673 1643
1674 1644 if (vp->v_type != VLNK)
1675 1645 return (EINVAL);
1676 1646
1677 1647 rw_enter(&tp->tn_rwlock, RW_READER);
1678 1648 rw_enter(&tp->tn_contents, RW_READER);
1679 1649 error = uiomove(tp->tn_symlink, tp->tn_size, UIO_READ, uiop);
1680 1650 gethrestime(&tp->tn_atime);
1681 1651 rw_exit(&tp->tn_contents);
1682 1652 rw_exit(&tp->tn_rwlock);
1683 1653 return (error);
1684 1654 }
1685 1655
1686 1656 /* ARGSUSED */
1687 1657 static int
1688 1658 tmp_fsync(
1689 1659 struct vnode *vp,
1690 1660 int syncflag,
1691 1661 struct cred *cred,
1692 1662 caller_context_t *ct)
1693 1663 {
1694 1664 return (0);
1695 1665 }
1696 1666
1697 1667 /* ARGSUSED */
1698 1668 static void
1699 1669 tmp_inactive(struct vnode *vp, struct cred *cred, caller_context_t *ct)
1700 1670 {
1701 1671 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1702 1672 struct tmount *tm = (struct tmount *)VFSTOTM(vp->v_vfsp);
1703 1673
1704 1674 rw_enter(&tp->tn_rwlock, RW_WRITER);
|
↓ open down ↓ |
44 lines elided |
↑ open up ↑ |
1705 1675 top:
1706 1676 mutex_enter(&tp->tn_tlock);
1707 1677 mutex_enter(&vp->v_lock);
1708 1678 ASSERT(vp->v_count >= 1);
1709 1679
1710 1680 /*
1711 1681 * If we don't have the last hold or the link count is non-zero,
1712 1682 * there's little to do -- just drop our hold.
1713 1683 */
1714 1684 if (vp->v_count > 1 || tp->tn_nlink != 0) {
1715 - if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED) {
1716 - /*
1717 - * Since the file system was forcibly unmounted, we can
1718 - * have a case (v_count == 1, tn_nlink != 0) where this
1719 - * file was open so we didn't add an extra hold on the
1720 - * file in tmp_unmount. We are counting on the
1721 - * interaction of the hold made in tmp_unmount and
1722 - * rele-ed in tmp_vfsfree so we need to be sure we
1723 - * don't decrement in this case.
1724 - */
1725 - if (vp->v_count > 1)
1726 - vp->v_count--;
1727 - } else {
1728 - vp->v_count--;
1729 - }
1685 + vp->v_count--;
1730 1686 mutex_exit(&vp->v_lock);
1731 1687 mutex_exit(&tp->tn_tlock);
1732 1688 rw_exit(&tp->tn_rwlock);
1733 - /* If the filesystem was umounted by force, rele the vfs ref */
1734 - if (tm->tm_vfsp->vfs_flag & VFS_UNMOUNTED)
1735 - VFS_RELE(tm->tm_vfsp);
1736 1689 return;
1737 1690 }
1738 1691
1739 1692 /*
1740 1693 * We have the last hold *and* the link count is zero, so this
1741 1694 * tmpnode is dead from the filesystem's viewpoint. However,
1742 1695 * if the tmpnode has any pages associated with it (i.e. if it's
1743 1696 * a normal file with non-zero size), the tmpnode can still be
1744 1697 * discovered by pageout or fsflush via the page vnode pointers.
1745 1698 * In this case we must drop all our locks, truncate the tmpnode,
1746 1699 * and try the whole dance again.
1747 1700 */
1748 1701 if (tp->tn_size != 0) {
1749 1702 if (tp->tn_type == VREG) {
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
1750 1703 mutex_exit(&vp->v_lock);
1751 1704 mutex_exit(&tp->tn_tlock);
1752 1705 rw_enter(&tp->tn_contents, RW_WRITER);
1753 1706 (void) tmpnode_trunc(tm, tp, 0);
1754 1707 rw_exit(&tp->tn_contents);
1755 1708 ASSERT(tp->tn_size == 0);
1756 1709 ASSERT(tp->tn_nblocks == 0);
1757 1710 goto top;
1758 1711 }
1759 1712 if (tp->tn_type == VLNK)
1760 - tmp_kmem_free(tm, tp->tn_symlink, tp->tn_size + 1);
1713 + tmp_memfree(tp->tn_symlink, tp->tn_size + 1);
1761 1714 }
1762 1715
1763 1716 /*
1764 1717 * Remove normal file/dir's xattr dir and xattrs.
1765 1718 */
1766 1719 if (tp->tn_xattrdp) {
1767 1720 struct tmpnode *xtp = tp->tn_xattrdp;
1768 1721
1769 1722 ASSERT(xtp->tn_flags & ISXATTR);
1770 1723 tmpnode_hold(xtp);
1771 1724 rw_enter(&xtp->tn_rwlock, RW_WRITER);
1772 1725 tdirtrunc(xtp);
1773 1726 DECR_COUNT(&xtp->tn_nlink, &xtp->tn_tlock);
1774 1727 tp->tn_xattrdp = NULL;
1775 1728 rw_exit(&xtp->tn_rwlock);
1776 1729 tmpnode_rele(xtp);
1777 1730 }
1778 1731
1779 1732 mutex_exit(&vp->v_lock);
1780 1733 mutex_exit(&tp->tn_tlock);
1781 1734 /* Here's our chance to send invalid event while we're between locks */
1782 1735 vn_invalid(TNTOV(tp));
1783 1736 mutex_enter(&tm->tm_contents);
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
1784 1737 if (tp->tn_forw == NULL)
1785 1738 tm->tm_rootnode->tn_back = tp->tn_back;
1786 1739 else
1787 1740 tp->tn_forw->tn_back = tp->tn_back;
1788 1741 tp->tn_back->tn_forw = tp->tn_forw;
1789 1742 mutex_exit(&tm->tm_contents);
1790 1743 rw_exit(&tp->tn_rwlock);
1791 1744 rw_destroy(&tp->tn_rwlock);
1792 1745 mutex_destroy(&tp->tn_tlock);
1793 1746 vn_free(TNTOV(tp));
1794 - tmp_kmem_free(tm, tp, sizeof (struct tmpnode));
1795 -
1796 - /* If the filesystem was umounted by force, rele the vfs ref */
1797 - if (tm->tm_vfsp->vfs_flag & VFS_UNMOUNTED)
1798 - VFS_RELE(tm->tm_vfsp);
1747 + tmp_memfree(tp, sizeof (struct tmpnode));
1799 1748 }
1800 1749
1801 1750 /* ARGSUSED2 */
1802 1751 static int
1803 1752 tmp_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct)
1804 1753 {
1805 1754 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
1806 1755 struct tfid *tfid;
1807 1756
1808 1757 if (fidp->fid_len < (sizeof (struct tfid) - sizeof (ushort_t))) {
1809 1758 fidp->fid_len = sizeof (struct tfid) - sizeof (ushort_t);
1810 1759 return (ENOSPC);
1811 1760 }
1812 1761
1813 1762 tfid = (struct tfid *)fidp;
1814 1763 bzero(tfid, sizeof (struct tfid));
1815 1764 tfid->tfid_len = (int)sizeof (struct tfid) - sizeof (ushort_t);
1816 1765
1817 1766 tfid->tfid_ino = tp->tn_nodeid;
1818 1767 tfid->tfid_gen = tp->tn_gen;
1819 1768
1820 1769 return (0);
1821 1770 }
1822 1771
1823 1772
1824 1773 /*
1825 1774 * Return all the pages from [off..off+len] in given file
1826 1775 */
1827 1776 /* ARGSUSED */
1828 1777 static int
1829 1778 tmp_getpage(
1830 1779 struct vnode *vp,
1831 1780 offset_t off,
1832 1781 size_t len,
1833 1782 uint_t *protp,
1834 1783 page_t *pl[],
1835 1784 size_t plsz,
1836 1785 struct seg *seg,
1837 1786 caddr_t addr,
1838 1787 enum seg_rw rw,
1839 1788 struct cred *cr,
1840 1789 caller_context_t *ct)
1841 1790 {
1842 1791 int err = 0;
1843 1792 struct tmpnode *tp = VTOTN(vp);
1844 1793 anoff_t toff = (anoff_t)off;
1845 1794 size_t tlen = len;
1846 1795 u_offset_t tmpoff;
1847 1796 timestruc_t now;
1848 1797
1849 1798 rw_enter(&tp->tn_contents, RW_READER);
1850 1799
1851 1800 if (off + len > tp->tn_size + PAGEOFFSET) {
1852 1801 err = EFAULT;
1853 1802 goto out;
1854 1803 }
1855 1804 /*
1856 1805 * Look for holes (no anon slot) in faulting range. If there are
1857 1806 * holes we have to switch to a write lock and fill them in. Swap
1858 1807 * space for holes was already reserved when the file was grown.
1859 1808 */
1860 1809 tmpoff = toff;
1861 1810 if (non_anon(tp->tn_anon, btop(off), &tmpoff, &tlen)) {
1862 1811 if (!rw_tryupgrade(&tp->tn_contents)) {
1863 1812 rw_exit(&tp->tn_contents);
1864 1813 rw_enter(&tp->tn_contents, RW_WRITER);
1865 1814 /* Size may have changed when lock was dropped */
1866 1815 if (off + len > tp->tn_size + PAGEOFFSET) {
1867 1816 err = EFAULT;
1868 1817 goto out;
1869 1818 }
1870 1819 }
1871 1820 for (toff = (anoff_t)off; toff < (anoff_t)off + len;
1872 1821 toff += PAGESIZE) {
1873 1822 if (anon_get_ptr(tp->tn_anon, btop(toff)) == NULL) {
1874 1823 /* XXX - may allocate mem w. write lock held */
1875 1824 (void) anon_set_ptr(tp->tn_anon, btop(toff),
1876 1825 anon_alloc(vp, toff), ANON_SLEEP);
1877 1826 tp->tn_nblocks++;
1878 1827 }
1879 1828 }
1880 1829 rw_downgrade(&tp->tn_contents);
1881 1830 }
1882 1831
1883 1832
1884 1833 err = pvn_getpages(tmp_getapage, vp, (u_offset_t)off, len, protp,
1885 1834 pl, plsz, seg, addr, rw, cr);
1886 1835
1887 1836 gethrestime(&now);
1888 1837 tp->tn_atime = now;
1889 1838 if (rw == S_WRITE)
1890 1839 tp->tn_mtime = now;
1891 1840
1892 1841 out:
1893 1842 rw_exit(&tp->tn_contents);
1894 1843 return (err);
1895 1844 }
1896 1845
1897 1846 /*
1898 1847 * Called from pvn_getpages to get a particular page.
1899 1848 */
1900 1849 /*ARGSUSED*/
1901 1850 static int
1902 1851 tmp_getapage(
1903 1852 struct vnode *vp,
1904 1853 u_offset_t off,
1905 1854 size_t len,
1906 1855 uint_t *protp,
1907 1856 page_t *pl[],
1908 1857 size_t plsz,
1909 1858 struct seg *seg,
|
↓ open down ↓ |
101 lines elided |
↑ open up ↑ |
1910 1859 caddr_t addr,
1911 1860 enum seg_rw rw,
1912 1861 struct cred *cr)
1913 1862 {
1914 1863 struct page *pp;
1915 1864 int flags;
1916 1865 int err = 0;
1917 1866 struct vnode *pvp;
1918 1867 u_offset_t poff;
1919 1868
1920 - /* If the filesystem was umounted by force, return immediately. */
1921 - if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
1922 - return (EIO);
1923 -
1924 1869 if (protp != NULL)
1925 1870 *protp = PROT_ALL;
1926 1871 again:
1927 1872 if (pp = page_lookup(vp, off, rw == S_CREATE ? SE_EXCL : SE_SHARED)) {
1928 1873 if (pl) {
1929 1874 pl[0] = pp;
1930 1875 pl[1] = NULL;
1931 1876 } else {
1932 1877 page_unlock(pp);
1933 1878 }
1934 1879 } else {
1935 1880 pp = page_create_va(vp, off, PAGESIZE,
1936 1881 PG_WAIT | PG_EXCL, seg, addr);
1937 1882 /*
1938 1883 * Someone raced in and created the page after we did the
1939 1884 * lookup but before we did the create, so go back and
1940 1885 * try to look it up again.
1941 1886 */
1942 1887 if (pp == NULL)
1943 1888 goto again;
1944 1889 /*
1945 1890 * Fill page from backing store, if any. If none, then
1946 1891 * either this is a newly filled hole or page must have
1947 1892 * been unmodified and freed so just zero it out.
1948 1893 */
1949 1894 err = swap_getphysname(vp, off, &pvp, &poff);
1950 1895 if (err) {
1951 1896 panic("tmp_getapage: no anon slot vp %p "
1952 1897 "off %llx pp %p\n", (void *)vp, off, (void *)pp);
1953 1898 }
1954 1899 if (pvp) {
1955 1900 flags = (pl == NULL ? B_ASYNC|B_READ : B_READ);
1956 1901 err = VOP_PAGEIO(pvp, pp, (u_offset_t)poff, PAGESIZE,
1957 1902 flags, cr, NULL);
1958 1903 if (flags & B_ASYNC)
1959 1904 pp = NULL;
1960 1905 } else if (rw != S_CREATE) {
1961 1906 pagezero(pp, 0, PAGESIZE);
1962 1907 }
1963 1908 if (err && pp)
1964 1909 pvn_read_done(pp, B_ERROR);
1965 1910 if (err == 0) {
1966 1911 if (pl)
1967 1912 pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw);
1968 1913 else
1969 1914 pvn_io_done(pp);
1970 1915 }
1971 1916 }
1972 1917 return (err);
1973 1918 }
1974 1919
1975 1920
1976 1921 /*
1977 1922 * Flags are composed of {B_INVAL, B_DIRTY B_FREE, B_DONTNEED}.
1978 1923 * If len == 0, do from off to EOF.
1979 1924 */
1980 1925 static int tmp_nopage = 0; /* Don't do tmp_putpage's if set */
1981 1926
1982 1927 /* ARGSUSED */
1983 1928 int
1984 1929 tmp_putpage(
1985 1930 register struct vnode *vp,
1986 1931 offset_t off,
1987 1932 size_t len,
1988 1933 int flags,
1989 1934 struct cred *cr,
1990 1935 caller_context_t *ct)
1991 1936 {
1992 1937 register page_t *pp;
1993 1938 u_offset_t io_off;
1994 1939 size_t io_len = 0;
1995 1940 int err = 0;
1996 1941 struct tmpnode *tp = VTOTN(vp);
1997 1942 int dolock;
1998 1943
1999 1944 if (tmp_nopage)
2000 1945 return (0);
2001 1946
2002 1947 ASSERT(vp->v_count != 0);
2003 1948
2004 1949 if (vp->v_flag & VNOMAP)
2005 1950 return (ENOSYS);
2006 1951
2007 1952 /*
2008 1953 * This being tmpfs, we don't ever do i/o unless we really
2009 1954 * have to (when we're low on memory and pageout calls us
2010 1955 * with B_ASYNC | B_FREE or the user explicitly asks for it with
2011 1956 * B_DONTNEED).
2012 1957 * XXX to approximately track the mod time like ufs we should
2013 1958 * update the times here. The problem is, once someone does a
2014 1959 * store we never clear the mod bit and do i/o, thus fsflush
2015 1960 * will keep calling us every 30 seconds to do the i/o and we'll
2016 1961 * continually update the mod time. At least we update the mod
2017 1962 * time on the first store because this results in a call to getpage.
2018 1963 */
2019 1964 if (flags != (B_ASYNC | B_FREE) && (flags & B_INVAL) == 0 &&
2020 1965 (flags & B_DONTNEED) == 0)
2021 1966 return (0);
2022 1967 /*
2023 1968 * If this thread owns the lock, i.e., this thread grabbed it
2024 1969 * as writer somewhere above, then we don't need to grab the
2025 1970 * lock as reader in this routine.
2026 1971 */
2027 1972 dolock = (rw_owner(&tp->tn_contents) != curthread);
2028 1973
2029 1974 /*
2030 1975 * If this is pageout don't block on the lock as you could deadlock
2031 1976 * when freemem == 0 (another thread has the read lock and is blocked
2032 1977 * creating a page, and a third thread is waiting to get the writers
2033 1978 * lock - waiting writers priority blocks us from getting the read
2034 1979 * lock). Of course, if the only freeable pages are on this tmpnode
2035 1980 * we're hosed anyways. A better solution might be a new lock type.
2036 1981 * Note: ufs has the same problem.
2037 1982 */
2038 1983 if (curproc == proc_pageout) {
2039 1984 if (!rw_tryenter(&tp->tn_contents, RW_READER))
2040 1985 return (ENOMEM);
2041 1986 } else if (dolock)
2042 1987 rw_enter(&tp->tn_contents, RW_READER);
2043 1988
2044 1989 if (!vn_has_cached_data(vp))
2045 1990 goto out;
2046 1991
2047 1992 if (len == 0) {
2048 1993 if (curproc == proc_pageout) {
2049 1994 panic("tmp: pageout can't block");
2050 1995 /*NOTREACHED*/
2051 1996 }
2052 1997
2053 1998 /* Search the entire vp list for pages >= off. */
2054 1999 err = pvn_vplist_dirty(vp, (u_offset_t)off, tmp_putapage,
2055 2000 flags, cr);
2056 2001 } else {
2057 2002 u_offset_t eoff;
2058 2003
2059 2004 /*
2060 2005 * Loop over all offsets in the range [off...off + len]
2061 2006 * looking for pages to deal with.
2062 2007 */
2063 2008 eoff = MIN(off + len, tp->tn_size);
2064 2009 for (io_off = off; io_off < eoff; io_off += io_len) {
2065 2010 /*
2066 2011 * If we are not invalidating, synchronously
2067 2012 * freeing or writing pages use the routine
2068 2013 * page_lookup_nowait() to prevent reclaiming
2069 2014 * them from the free list.
2070 2015 */
2071 2016 if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
2072 2017 pp = page_lookup(vp, io_off,
2073 2018 (flags & (B_INVAL | B_FREE)) ?
2074 2019 SE_EXCL : SE_SHARED);
2075 2020 } else {
2076 2021 pp = page_lookup_nowait(vp, io_off,
2077 2022 (flags & B_FREE) ? SE_EXCL : SE_SHARED);
2078 2023 }
2079 2024
2080 2025 if (pp == NULL || pvn_getdirty(pp, flags) == 0)
2081 2026 io_len = PAGESIZE;
2082 2027 else {
2083 2028 err = tmp_putapage(vp, pp, &io_off, &io_len,
2084 2029 flags, cr);
2085 2030 if (err != 0)
2086 2031 break;
2087 2032 }
2088 2033 }
2089 2034 }
2090 2035 /* If invalidating, verify all pages on vnode list are gone. */
2091 2036 if (err == 0 && off == 0 && len == 0 &&
2092 2037 (flags & B_INVAL) && vn_has_cached_data(vp)) {
2093 2038 panic("tmp_putpage: B_INVAL, pages not gone");
2094 2039 /*NOTREACHED*/
2095 2040 }
2096 2041 out:
2097 2042 if ((curproc == proc_pageout) || dolock)
2098 2043 rw_exit(&tp->tn_contents);
2099 2044 /*
2100 2045 * Only reason putapage is going to give us SE_NOSWAP as error
2101 2046 * is when we ask a page to be written to physical backing store
2102 2047 * and there is none. Ignore this because we might be dealing
2103 2048 * with a swap page which does not have any backing store
2104 2049 * on disk. In any other case we won't get this error over here.
2105 2050 */
2106 2051 if (err == SE_NOSWAP)
2107 2052 err = 0;
2108 2053 return (err);
2109 2054 }
2110 2055
2111 2056 long tmp_putpagecnt, tmp_pagespushed;
2112 2057
2113 2058 /*
2114 2059 * Write out a single page.
2115 2060 * For tmpfs this means choose a physical swap slot and write the page
2116 2061 * out using VOP_PAGEIO. For performance, we attempt to kluster; i.e.,
2117 2062 * we try to find a bunch of other dirty pages adjacent in the file
2118 2063 * and a bunch of contiguous swap slots, and then write all the pages
2119 2064 * out in a single i/o.
2120 2065 */
2121 2066 /*ARGSUSED*/
2122 2067 static int
2123 2068 tmp_putapage(
2124 2069 struct vnode *vp,
2125 2070 page_t *pp,
2126 2071 u_offset_t *offp,
2127 2072 size_t *lenp,
2128 2073 int flags,
2129 2074 struct cred *cr)
2130 2075 {
2131 2076 int err;
2132 2077 ulong_t klstart, kllen;
2133 2078 page_t *pplist, *npplist;
2134 2079 extern int klustsize;
|
↓ open down ↓ |
201 lines elided |
↑ open up ↑ |
2135 2080 long tmp_klustsize;
2136 2081 struct tmpnode *tp;
2137 2082 size_t pp_off, pp_len;
2138 2083 u_offset_t io_off;
2139 2084 size_t io_len;
2140 2085 struct vnode *pvp;
2141 2086 u_offset_t pstart;
2142 2087 u_offset_t offset;
2143 2088 u_offset_t tmpoff;
2144 2089
2145 - /* If the filesystem was umounted by force, return immediately. */
2146 - if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
2147 - return (EIO);
2148 -
2149 2090 ASSERT(PAGE_LOCKED(pp));
2150 2091
2151 2092 /* Kluster in tmp_klustsize chunks */
2152 2093 tp = VTOTN(vp);
2153 2094 tmp_klustsize = klustsize;
2154 2095 offset = pp->p_offset;
2155 2096 klstart = (offset / tmp_klustsize) * tmp_klustsize;
2156 2097 kllen = MIN(tmp_klustsize, tp->tn_size - klstart);
2157 2098
2158 2099 /* Get a kluster of pages */
2159 2100 pplist =
2160 2101 pvn_write_kluster(vp, pp, &tmpoff, &pp_len, klstart, kllen, flags);
2161 2102
2162 2103 pp_off = (size_t)tmpoff;
2163 2104
2164 2105 /*
2165 2106 * Get a cluster of physical offsets for the pages; the amount we
2166 2107 * get may be some subrange of what we ask for (io_off, io_len).
2167 2108 */
2168 2109 io_off = pp_off;
2169 2110 io_len = pp_len;
2170 2111 err = swap_newphysname(vp, offset, &io_off, &io_len, &pvp, &pstart);
2171 2112 ASSERT(err != SE_NOANON); /* anon slot must have been filled */
2172 2113 if (err) {
2173 2114 pvn_write_done(pplist, B_ERROR | B_WRITE | flags);
2174 2115 /*
2175 2116 * If this routine is called as a result of segvn_sync
2176 2117 * operation and we have no physical swap then we can get an
2177 2118 * error here. In such case we would return SE_NOSWAP as error.
2178 2119 * At this point, we expect only SE_NOSWAP.
2179 2120 */
2180 2121 ASSERT(err == SE_NOSWAP);
2181 2122 if (flags & B_INVAL)
2182 2123 err = ENOMEM;
2183 2124 goto out;
2184 2125 }
2185 2126 ASSERT(pp_off <= io_off && io_off + io_len <= pp_off + pp_len);
2186 2127 ASSERT(io_off <= offset && offset < io_off + io_len);
2187 2128
2188 2129 /* Toss pages at front/rear that we couldn't get physical backing for */
2189 2130 if (io_off != pp_off) {
2190 2131 npplist = NULL;
2191 2132 page_list_break(&pplist, &npplist, btop(io_off - pp_off));
2192 2133 ASSERT(pplist->p_offset == pp_off);
2193 2134 ASSERT(pplist->p_prev->p_offset == io_off - PAGESIZE);
2194 2135 pvn_write_done(pplist, B_ERROR | B_WRITE | flags);
2195 2136 pplist = npplist;
2196 2137 }
2197 2138 if (io_off + io_len < pp_off + pp_len) {
2198 2139 npplist = NULL;
2199 2140 page_list_break(&pplist, &npplist, btop(io_len));
2200 2141 ASSERT(npplist->p_offset == io_off + io_len);
2201 2142 ASSERT(npplist->p_prev->p_offset == pp_off + pp_len - PAGESIZE);
2202 2143 pvn_write_done(npplist, B_ERROR | B_WRITE | flags);
2203 2144 }
2204 2145
2205 2146 ASSERT(pplist->p_offset == io_off);
2206 2147 ASSERT(pplist->p_prev->p_offset == io_off + io_len - PAGESIZE);
2207 2148 ASSERT(btopr(io_len) <= btopr(kllen));
2208 2149
2209 2150 /* Do i/o on the remaining kluster */
2210 2151 err = VOP_PAGEIO(pvp, pplist, (u_offset_t)pstart, io_len,
2211 2152 B_WRITE | flags, cr, NULL);
2212 2153
2213 2154 if ((flags & B_ASYNC) == 0) {
2214 2155 pvn_write_done(pplist, ((err) ? B_ERROR : 0) | B_WRITE | flags);
2215 2156 }
2216 2157 out:
2217 2158 if (!err) {
2218 2159 if (offp)
2219 2160 *offp = io_off;
2220 2161 if (lenp)
2221 2162 *lenp = io_len;
2222 2163 tmp_putpagecnt++;
2223 2164 tmp_pagespushed += btop(io_len);
2224 2165 }
2225 2166 if (err && err != ENOMEM && err != SE_NOSWAP)
2226 2167 cmn_err(CE_WARN, "tmp_putapage: err %d\n", err);
2227 2168 return (err);
2228 2169 }
2229 2170
2230 2171 /* ARGSUSED */
2231 2172 static int
2232 2173 tmp_map(
2233 2174 struct vnode *vp,
2234 2175 offset_t off,
2235 2176 struct as *as,
2236 2177 caddr_t *addrp,
2237 2178 size_t len,
2238 2179 uchar_t prot,
2239 2180 uchar_t maxprot,
2240 2181 uint_t flags,
2241 2182 struct cred *cred,
2242 2183 caller_context_t *ct)
2243 2184 {
2244 2185 struct segvn_crargs vn_a;
2245 2186 struct tmpnode *tp = (struct tmpnode *)VTOTN(vp);
2246 2187 int error;
2247 2188
2248 2189 #ifdef _ILP32
2249 2190 if (len > MAXOFF_T)
2250 2191 return (ENOMEM);
2251 2192 #endif
2252 2193
2253 2194 if (vp->v_flag & VNOMAP)
2254 2195 return (ENOSYS);
2255 2196
2256 2197 if (off < 0 || (offset_t)(off + len) < 0 ||
2257 2198 off > MAXOFF_T || (off + len) > MAXOFF_T)
2258 2199 return (ENXIO);
2259 2200
2260 2201 if (vp->v_type != VREG)
2261 2202 return (ENODEV);
2262 2203
2263 2204 /*
2264 2205 * Don't allow mapping to locked file
2265 2206 */
2266 2207 if (vn_has_mandatory_locks(vp, tp->tn_mode)) {
2267 2208 return (EAGAIN);
2268 2209 }
2269 2210
2270 2211 as_rangelock(as);
2271 2212 error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
2272 2213 if (error != 0) {
2273 2214 as_rangeunlock(as);
2274 2215 return (error);
2275 2216 }
2276 2217
2277 2218 vn_a.vp = vp;
2278 2219 vn_a.offset = (u_offset_t)off;
2279 2220 vn_a.type = flags & MAP_TYPE;
2280 2221 vn_a.prot = prot;
2281 2222 vn_a.maxprot = maxprot;
2282 2223 vn_a.flags = flags & ~MAP_TYPE;
2283 2224 vn_a.cred = cred;
2284 2225 vn_a.amp = NULL;
2285 2226 vn_a.szc = 0;
2286 2227 vn_a.lgrp_mem_policy_flags = 0;
2287 2228
2288 2229 error = as_map(as, *addrp, len, segvn_create, &vn_a);
2289 2230 as_rangeunlock(as);
2290 2231 return (error);
2291 2232 }
2292 2233
2293 2234 /*
2294 2235 * tmp_addmap and tmp_delmap can't be called since the vp
2295 2236 * maintained in the segvn mapping is NULL.
2296 2237 */
2297 2238 /* ARGSUSED */
2298 2239 static int
2299 2240 tmp_addmap(
2300 2241 struct vnode *vp,
2301 2242 offset_t off,
2302 2243 struct as *as,
2303 2244 caddr_t addr,
2304 2245 size_t len,
2305 2246 uchar_t prot,
2306 2247 uchar_t maxprot,
2307 2248 uint_t flags,
2308 2249 struct cred *cred,
2309 2250 caller_context_t *ct)
2310 2251 {
2311 2252 return (0);
2312 2253 }
2313 2254
2314 2255 /* ARGSUSED */
2315 2256 static int
2316 2257 tmp_delmap(
2317 2258 struct vnode *vp,
2318 2259 offset_t off,
2319 2260 struct as *as,
2320 2261 caddr_t addr,
2321 2262 size_t len,
2322 2263 uint_t prot,
2323 2264 uint_t maxprot,
2324 2265 uint_t flags,
2325 2266 struct cred *cred,
2326 2267 caller_context_t *ct)
2327 2268 {
2328 2269 return (0);
2329 2270 }
2330 2271
2331 2272 static int
2332 2273 tmp_freesp(struct vnode *vp, struct flock64 *lp, int flag)
2333 2274 {
2334 2275 register int i;
2335 2276 register struct tmpnode *tp = VTOTN(vp);
2336 2277 int error;
2337 2278
2338 2279 ASSERT(vp->v_type == VREG);
2339 2280 ASSERT(lp->l_start >= 0);
2340 2281
2341 2282 if (lp->l_len != 0)
2342 2283 return (EINVAL);
2343 2284
2344 2285 rw_enter(&tp->tn_rwlock, RW_WRITER);
2345 2286 if (tp->tn_size == lp->l_start) {
2346 2287 rw_exit(&tp->tn_rwlock);
2347 2288 return (0);
2348 2289 }
2349 2290
2350 2291 /*
2351 2292 * Check for any mandatory locks on the range
2352 2293 */
2353 2294 if (MANDLOCK(vp, tp->tn_mode)) {
2354 2295 long save_start;
2355 2296
2356 2297 save_start = lp->l_start;
2357 2298
2358 2299 if (tp->tn_size < lp->l_start) {
2359 2300 /*
2360 2301 * "Truncate up" case: need to make sure there
2361 2302 * is no lock beyond current end-of-file. To
2362 2303 * do so, we need to set l_start to the size
2363 2304 * of the file temporarily.
2364 2305 */
2365 2306 lp->l_start = tp->tn_size;
2366 2307 }
2367 2308 lp->l_type = F_WRLCK;
2368 2309 lp->l_sysid = 0;
2369 2310 lp->l_pid = ttoproc(curthread)->p_pid;
2370 2311 i = (flag & (FNDELAY|FNONBLOCK)) ? 0 : SLPFLCK;
2371 2312 if ((i = reclock(vp, lp, i, 0, lp->l_start, NULL)) != 0 ||
2372 2313 lp->l_type != F_UNLCK) {
2373 2314 rw_exit(&tp->tn_rwlock);
2374 2315 return (i ? i : EAGAIN);
2375 2316 }
2376 2317
2377 2318 lp->l_start = save_start;
2378 2319 }
2379 2320 VFSTOTM(vp->v_vfsp);
2380 2321
2381 2322 rw_enter(&tp->tn_contents, RW_WRITER);
2382 2323 error = tmpnode_trunc((struct tmount *)VFSTOTM(vp->v_vfsp),
2383 2324 tp, (ulong_t)lp->l_start);
2384 2325 rw_exit(&tp->tn_contents);
2385 2326 rw_exit(&tp->tn_rwlock);
2386 2327 return (error);
2387 2328 }
2388 2329
2389 2330 /* ARGSUSED */
2390 2331 static int
2391 2332 tmp_space(
2392 2333 struct vnode *vp,
2393 2334 int cmd,
2394 2335 struct flock64 *bfp,
2395 2336 int flag,
2396 2337 offset_t offset,
2397 2338 cred_t *cred,
2398 2339 caller_context_t *ct)
2399 2340 {
2400 2341 int error;
2401 2342
2402 2343 if (cmd != F_FREESP)
2403 2344 return (EINVAL);
2404 2345 if ((error = convoff(vp, bfp, 0, (offset_t)offset)) == 0) {
2405 2346 if ((bfp->l_start > MAXOFF_T) || (bfp->l_len > MAXOFF_T))
2406 2347 return (EFBIG);
2407 2348 error = tmp_freesp(vp, bfp, flag);
2408 2349
2409 2350 if (error == 0) {
2410 2351 if (bfp->l_start == 0) {
2411 2352 vnevent_truncate(vp, ct);
2412 2353 } else {
2413 2354 vnevent_resize(vp, ct);
2414 2355 }
2415 2356 }
2416 2357 }
2417 2358 return (error);
2418 2359 }
2419 2360
2420 2361 /* ARGSUSED */
2421 2362 static int
2422 2363 tmp_seek(
2423 2364 struct vnode *vp,
2424 2365 offset_t ooff,
2425 2366 offset_t *noffp,
2426 2367 caller_context_t *ct)
2427 2368 {
2428 2369 return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);
2429 2370 }
2430 2371
2431 2372 /* ARGSUSED2 */
2432 2373 static int
2433 2374 tmp_rwlock(struct vnode *vp, int write_lock, caller_context_t *ctp)
2434 2375 {
2435 2376 struct tmpnode *tp = VTOTN(vp);
2436 2377
2437 2378 if (write_lock) {
2438 2379 rw_enter(&tp->tn_rwlock, RW_WRITER);
2439 2380 } else {
2440 2381 rw_enter(&tp->tn_rwlock, RW_READER);
2441 2382 }
2442 2383 return (write_lock);
2443 2384 }
2444 2385
2445 2386 /* ARGSUSED1 */
2446 2387 static void
2447 2388 tmp_rwunlock(struct vnode *vp, int write_lock, caller_context_t *ctp)
2448 2389 {
2449 2390 struct tmpnode *tp = VTOTN(vp);
2450 2391
2451 2392 rw_exit(&tp->tn_rwlock);
2452 2393 }
2453 2394
2454 2395 static int
2455 2396 tmp_pathconf(
2456 2397 struct vnode *vp,
2457 2398 int cmd,
2458 2399 ulong_t *valp,
2459 2400 cred_t *cr,
2460 2401 caller_context_t *ct)
2461 2402 {
2462 2403 struct tmpnode *tp = NULL;
2463 2404 int error;
2464 2405
2465 2406 switch (cmd) {
2466 2407 case _PC_XATTR_EXISTS:
2467 2408 if (vp->v_vfsp->vfs_flag & VFS_XATTR) {
2468 2409 *valp = 0; /* assume no attributes */
2469 2410 error = 0; /* okay to ask */
2470 2411 tp = VTOTN(vp);
2471 2412 rw_enter(&tp->tn_rwlock, RW_READER);
2472 2413 if (tp->tn_xattrdp) {
2473 2414 rw_enter(&tp->tn_xattrdp->tn_rwlock, RW_READER);
2474 2415 /* do not count "." and ".." */
2475 2416 if (tp->tn_xattrdp->tn_dirents > 2)
2476 2417 *valp = 1;
2477 2418 rw_exit(&tp->tn_xattrdp->tn_rwlock);
2478 2419 }
2479 2420 rw_exit(&tp->tn_rwlock);
2480 2421 } else {
2481 2422 error = EINVAL;
2482 2423 }
2483 2424 break;
2484 2425 case _PC_SATTR_ENABLED:
2485 2426 case _PC_SATTR_EXISTS:
2486 2427 *valp = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) &&
2487 2428 (vp->v_type == VREG || vp->v_type == VDIR);
2488 2429 error = 0;
2489 2430 break;
2490 2431 case _PC_TIMESTAMP_RESOLUTION:
2491 2432 /* nanosecond timestamp resolution */
2492 2433 *valp = 1L;
2493 2434 error = 0;
2494 2435 break;
2495 2436 default:
2496 2437 error = fs_pathconf(vp, cmd, valp, cr, ct);
2497 2438 }
2498 2439 return (error);
2499 2440 }
2500 2441
2501 2442
2502 2443 struct vnodeops *tmp_vnodeops;
2503 2444
2504 2445 const fs_operation_def_t tmp_vnodeops_template[] = {
2505 2446 VOPNAME_OPEN, { .vop_open = tmp_open },
2506 2447 VOPNAME_CLOSE, { .vop_close = tmp_close },
2507 2448 VOPNAME_READ, { .vop_read = tmp_read },
2508 2449 VOPNAME_WRITE, { .vop_write = tmp_write },
2509 2450 VOPNAME_IOCTL, { .vop_ioctl = tmp_ioctl },
2510 2451 VOPNAME_GETATTR, { .vop_getattr = tmp_getattr },
2511 2452 VOPNAME_SETATTR, { .vop_setattr = tmp_setattr },
2512 2453 VOPNAME_ACCESS, { .vop_access = tmp_access },
2513 2454 VOPNAME_LOOKUP, { .vop_lookup = tmp_lookup },
2514 2455 VOPNAME_CREATE, { .vop_create = tmp_create },
2515 2456 VOPNAME_REMOVE, { .vop_remove = tmp_remove },
2516 2457 VOPNAME_LINK, { .vop_link = tmp_link },
2517 2458 VOPNAME_RENAME, { .vop_rename = tmp_rename },
2518 2459 VOPNAME_MKDIR, { .vop_mkdir = tmp_mkdir },
2519 2460 VOPNAME_RMDIR, { .vop_rmdir = tmp_rmdir },
2520 2461 VOPNAME_READDIR, { .vop_readdir = tmp_readdir },
2521 2462 VOPNAME_SYMLINK, { .vop_symlink = tmp_symlink },
2522 2463 VOPNAME_READLINK, { .vop_readlink = tmp_readlink },
2523 2464 VOPNAME_FSYNC, { .vop_fsync = tmp_fsync },
2524 2465 VOPNAME_INACTIVE, { .vop_inactive = tmp_inactive },
2525 2466 VOPNAME_FID, { .vop_fid = tmp_fid },
2526 2467 VOPNAME_RWLOCK, { .vop_rwlock = tmp_rwlock },
2527 2468 VOPNAME_RWUNLOCK, { .vop_rwunlock = tmp_rwunlock },
2528 2469 VOPNAME_SEEK, { .vop_seek = tmp_seek },
2529 2470 VOPNAME_SPACE, { .vop_space = tmp_space },
2530 2471 VOPNAME_GETPAGE, { .vop_getpage = tmp_getpage },
2531 2472 VOPNAME_PUTPAGE, { .vop_putpage = tmp_putpage },
2532 2473 VOPNAME_MAP, { .vop_map = tmp_map },
2533 2474 VOPNAME_ADDMAP, { .vop_addmap = tmp_addmap },
2534 2475 VOPNAME_DELMAP, { .vop_delmap = tmp_delmap },
2535 2476 VOPNAME_PATHCONF, { .vop_pathconf = tmp_pathconf },
2536 2477 VOPNAME_VNEVENT, { .vop_vnevent = fs_vnevent_support },
2537 2478 NULL, NULL
2538 2479 };
|
↓ open down ↓ |
380 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX