Print this page
7653 tmpfs: calling unlink() on a directory which isn't empty should fail
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/tmpfs/tmp_dir.c
+++ new/usr/src/uts/common/fs/tmpfs/tmp_dir.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
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
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]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 + *
25 + * Copyright 2016 RackTop Systems.
24 26 */
25 27
26 -#pragma ident "%Z%%M% %I% %E% SMI"
27 -
28 28 #include <sys/types.h>
29 29 #include <sys/param.h>
30 30 #include <sys/sysmacros.h>
31 31 #include <sys/systm.h>
32 32 #include <sys/time.h>
33 33 #include <sys/vfs.h>
34 34 #include <sys/vnode.h>
35 35 #include <sys/errno.h>
36 36 #include <sys/cmn_err.h>
37 37 #include <sys/cred.h>
38 38 #include <sys/stat.h>
39 39 #include <sys/debug.h>
40 40 #include <sys/policy.h>
41 41 #include <sys/fs/tmpnode.h>
42 42 #include <sys/fs/tmp.h>
43 43 #include <sys/vtrace.h>
44 44
45 45 static int tdircheckpath(struct tmpnode *, struct tmpnode *, struct cred *);
46 46 static int tdirrename(struct tmpnode *, struct tmpnode *, struct tmpnode *,
47 47 char *, struct tmpnode *, struct tdirent *, struct cred *);
48 48 static void tdirfixdotdot(struct tmpnode *, struct tmpnode *, struct tmpnode *);
49 49 static int tdirmaketnode(struct tmpnode *, struct tmount *, struct vattr *,
50 50 enum de_op, struct tmpnode **, struct cred *);
51 51 static int tdiraddentry(struct tmpnode *, struct tmpnode *, char *,
52 52 enum de_op, struct tmpnode *);
53 53
54 54
55 55 #define T_HASH_SIZE 8192 /* must be power of 2 */
56 56 #define T_MUTEX_SIZE 64
57 57
58 58 static struct tdirent *t_hashtable[T_HASH_SIZE];
59 59 static kmutex_t t_hashmutex[T_MUTEX_SIZE];
60 60
61 61 #define T_HASH_INDEX(a) ((a) & (T_HASH_SIZE-1))
62 62 #define T_MUTEX_INDEX(a) ((a) & (T_MUTEX_SIZE-1))
63 63
64 64 #define TMPFS_HASH(tp, name, hash) \
65 65 { \
66 66 char Xc, *Xcp; \
67 67 hash = (uint_t)(uintptr_t)(tp) >> 8; \
68 68 for (Xcp = (name); (Xc = *Xcp) != 0; Xcp++) \
69 69 hash = (hash << 4) + hash + (uint_t)Xc; \
70 70 }
71 71
72 72 void
73 73 tmpfs_hash_init(void)
74 74 {
75 75 int ix;
76 76
77 77 for (ix = 0; ix < T_MUTEX_SIZE; ix++)
78 78 mutex_init(&t_hashmutex[ix], NULL, MUTEX_DEFAULT, NULL);
79 79 }
80 80
81 81 /*
82 82 * This routine is where the rubber meets the road for identities.
83 83 */
84 84 static void
85 85 tmpfs_hash_in(struct tdirent *t)
86 86 {
87 87 uint_t hash;
88 88 struct tdirent **prevpp;
89 89 kmutex_t *t_hmtx;
90 90
91 91 TMPFS_HASH(t->td_parent, t->td_name, hash);
92 92 t->td_hash = hash;
93 93 prevpp = &t_hashtable[T_HASH_INDEX(hash)];
94 94 t_hmtx = &t_hashmutex[T_MUTEX_INDEX(hash)];
95 95 mutex_enter(t_hmtx);
96 96 t->td_link = *prevpp;
97 97 *prevpp = t;
98 98 mutex_exit(t_hmtx);
99 99 }
100 100
101 101 /*
102 102 * Remove tdirent *t from the hash list.
103 103 */
104 104 static void
105 105 tmpfs_hash_out(struct tdirent *t)
106 106 {
107 107 uint_t hash;
108 108 struct tdirent **prevpp;
109 109 kmutex_t *t_hmtx;
110 110
111 111 hash = t->td_hash;
112 112 prevpp = &t_hashtable[T_HASH_INDEX(hash)];
113 113 t_hmtx = &t_hashmutex[T_MUTEX_INDEX(hash)];
114 114 mutex_enter(t_hmtx);
115 115 while (*prevpp != t)
116 116 prevpp = &(*prevpp)->td_link;
117 117 *prevpp = t->td_link;
118 118 mutex_exit(t_hmtx);
119 119 }
120 120
121 121 /*
122 122 * Currently called by tdirrename() only.
123 123 * rename operation needs to be done with lock held, to ensure that
124 124 * no other operations can access the tmpnode at the same instance.
125 125 */
126 126 static void
127 127 tmpfs_hash_change(struct tdirent *tdp, struct tmpnode *fromtp)
128 128 {
129 129 uint_t hash;
130 130 kmutex_t *t_hmtx;
131 131
132 132 hash = tdp->td_hash;
133 133 t_hmtx = &t_hashmutex[T_MUTEX_INDEX(hash)];
134 134 mutex_enter(t_hmtx);
135 135 tdp->td_tmpnode = fromtp;
136 136 mutex_exit(t_hmtx);
137 137 }
138 138
139 139 static struct tdirent *
140 140 tmpfs_hash_lookup(char *name, struct tmpnode *parent, uint_t hold,
141 141 struct tmpnode **found)
142 142 {
143 143 struct tdirent *l;
144 144 uint_t hash;
145 145 kmutex_t *t_hmtx;
146 146 struct tmpnode *tnp;
147 147
148 148 TMPFS_HASH(parent, name, hash);
149 149 t_hmtx = &t_hashmutex[T_MUTEX_INDEX(hash)];
150 150 mutex_enter(t_hmtx);
151 151 l = t_hashtable[T_HASH_INDEX(hash)];
152 152 while (l) {
153 153 if ((l->td_hash == hash) &&
154 154 (l->td_parent == parent) &&
155 155 (strcmp(l->td_name, name) == 0)) {
156 156 /*
157 157 * We need to make sure that the tmpnode that
158 158 * we put a hold on is the same one that we pass back.
159 159 * Hence, temporary variable tnp is necessary.
160 160 */
161 161 tnp = l->td_tmpnode;
162 162 if (hold) {
163 163 ASSERT(tnp);
164 164 tmpnode_hold(tnp);
165 165 }
166 166 if (found)
167 167 *found = tnp;
168 168 mutex_exit(t_hmtx);
169 169 return (l);
170 170 } else {
171 171 l = l->td_link;
172 172 }
173 173 }
174 174 mutex_exit(t_hmtx);
175 175 return (NULL);
176 176 }
177 177
178 178 /*
179 179 * Search directory 'parent' for entry 'name'.
180 180 *
181 181 * The calling thread can't hold the write version
182 182 * of the rwlock for the directory being searched
183 183 *
184 184 * 0 is returned on success and *foundtp points
185 185 * to the found tmpnode with its vnode held.
186 186 */
187 187 int
188 188 tdirlookup(
189 189 struct tmpnode *parent,
190 190 char *name,
191 191 struct tmpnode **foundtp,
192 192 struct cred *cred)
193 193 {
194 194 int error;
195 195
196 196 *foundtp = NULL;
197 197 if (parent->tn_type != VDIR)
198 198 return (ENOTDIR);
199 199
200 200 if ((error = tmp_taccess(parent, VEXEC, cred)))
201 201 return (error);
202 202
203 203 if (*name == '\0') {
204 204 tmpnode_hold(parent);
205 205 *foundtp = parent;
206 206 return (0);
207 207 }
208 208
209 209 /*
210 210 * Search the directory for the matching name
211 211 * We need the lock protecting the tn_dir list
212 212 * so that it doesn't change out from underneath us.
213 213 * tmpfs_hash_lookup() will pass back the tmpnode
214 214 * with a hold on it.
215 215 */
216 216
217 217 if (tmpfs_hash_lookup(name, parent, 1, foundtp) != NULL) {
218 218 ASSERT(*foundtp);
219 219 return (0);
220 220 }
221 221
222 222 return (ENOENT);
223 223 }
224 224
225 225 /*
226 226 * Enter a directory entry for 'name' and 'tp' into directory 'dir'
227 227 *
228 228 * Returns 0 on success.
229 229 */
230 230 int
231 231 tdirenter(
232 232 struct tmount *tm,
233 233 struct tmpnode *dir, /* target directory to make entry in */
234 234 char *name, /* name of entry */
235 235 enum de_op op, /* entry operation */
236 236 struct tmpnode *fromparent, /* source directory if rename */
237 237 struct tmpnode *tp, /* source tmpnode, if link/rename */
238 238 struct vattr *va,
239 239 struct tmpnode **tpp, /* return tmpnode, if create/mkdir */
240 240 struct cred *cred,
241 241 caller_context_t *ctp)
242 242 {
243 243 struct tdirent *tdp;
244 244 struct tmpnode *found = NULL;
245 245 int error = 0;
246 246 char *s;
247 247
248 248 /*
249 249 * tn_rwlock is held to serialize direnter and dirdeletes
250 250 */
251 251 ASSERT(RW_WRITE_HELD(&dir->tn_rwlock));
252 252 ASSERT(dir->tn_type == VDIR);
253 253
254 254 /*
255 255 * Don't allow '/' characters in pathname component
256 256 * (thus in ufs_direnter()).
257 257 */
258 258 for (s = name; *s; s++)
259 259 if (*s == '/')
260 260 return (EACCES);
261 261
262 262 if (name[0] == '\0')
263 263 panic("tdirenter: NULL name");
264 264
265 265 /*
266 266 * For link and rename lock the source entry and check the link count
267 267 * to see if it has been removed while it was unlocked.
268 268 */
269 269 if (op == DE_LINK || op == DE_RENAME) {
270 270 if (tp != dir)
271 271 rw_enter(&tp->tn_rwlock, RW_WRITER);
272 272 mutex_enter(&tp->tn_tlock);
273 273 if (tp->tn_nlink == 0) {
274 274 mutex_exit(&tp->tn_tlock);
275 275 if (tp != dir)
276 276 rw_exit(&tp->tn_rwlock);
277 277 return (ENOENT);
278 278 }
279 279
280 280 if (tp->tn_nlink == MAXLINK) {
281 281 mutex_exit(&tp->tn_tlock);
282 282 if (tp != dir)
283 283 rw_exit(&tp->tn_rwlock);
284 284 return (EMLINK);
285 285 }
286 286 tp->tn_nlink++;
287 287 gethrestime(&tp->tn_ctime);
288 288 mutex_exit(&tp->tn_tlock);
289 289 if (tp != dir)
290 290 rw_exit(&tp->tn_rwlock);
291 291 }
292 292
293 293 /*
294 294 * This might be a "dangling detached directory".
295 295 * it could have been removed, but a reference
296 296 * to it kept in u_cwd. don't bother searching
297 297 * it, and with any luck the user will get tired
298 298 * of dealing with us and cd to some absolute
299 299 * pathway. *sigh*, thus in ufs, too.
300 300 */
301 301 if (dir->tn_nlink == 0) {
302 302 error = ENOENT;
303 303 goto out;
304 304 }
305 305
306 306 /*
307 307 * If this is a rename of a directory and the parent is
308 308 * different (".." must be changed), then the source
309 309 * directory must not be in the directory hierarchy
310 310 * above the target, as this would orphan everything
311 311 * below the source directory.
312 312 */
313 313 if (op == DE_RENAME) {
314 314 if (tp == dir) {
315 315 error = EINVAL;
316 316 goto out;
317 317 }
318 318 if (tp->tn_type == VDIR) {
319 319 if ((fromparent != dir) &&
320 320 (error = tdircheckpath(tp, dir, cred))) {
321 321 goto out;
322 322 }
323 323 }
324 324 }
325 325
326 326 /*
327 327 * Search for the entry. Return "found" if it exists.
328 328 */
329 329 tdp = tmpfs_hash_lookup(name, dir, 1, &found);
330 330
331 331 if (tdp) {
332 332 ASSERT(found);
333 333 switch (op) {
334 334 case DE_CREATE:
335 335 case DE_MKDIR:
336 336 if (tpp) {
337 337 *tpp = found;
338 338 error = EEXIST;
339 339 } else {
340 340 tmpnode_rele(found);
341 341 }
342 342 break;
343 343
344 344 case DE_RENAME:
345 345 error = tdirrename(fromparent, tp,
346 346 dir, name, found, tdp, cred);
347 347 if (error == 0) {
348 348 if (found != NULL) {
349 349 vnevent_rename_dest(TNTOV(found),
350 350 TNTOV(dir), name, ctp);
351 351 }
352 352 }
353 353
354 354 tmpnode_rele(found);
355 355 break;
356 356
357 357 case DE_LINK:
358 358 /*
359 359 * Can't link to an existing file.
360 360 */
361 361 error = EEXIST;
362 362 tmpnode_rele(found);
363 363 break;
364 364 }
365 365 } else {
366 366
367 367 /*
368 368 * The entry does not exist. Check write permission in
369 369 * directory to see if entry can be created.
370 370 */
371 371 if (error = tmp_taccess(dir, VWRITE, cred))
372 372 goto out;
373 373 if (op == DE_CREATE || op == DE_MKDIR) {
374 374 /*
375 375 * Make new tmpnode and directory entry as required.
376 376 */
377 377 error = tdirmaketnode(dir, tm, va, op, &tp, cred);
378 378 if (error)
379 379 goto out;
380 380 }
381 381 if (error = tdiraddentry(dir, tp, name, op, fromparent)) {
382 382 if (op == DE_CREATE || op == DE_MKDIR) {
383 383 /*
384 384 * Unmake the inode we just made.
385 385 */
386 386 rw_enter(&tp->tn_rwlock, RW_WRITER);
387 387 if ((tp->tn_type) == VDIR) {
388 388 ASSERT(tdp == NULL);
389 389 /*
390 390 * cleanup allocs made by tdirinit()
391 391 */
392 392 tdirtrunc(tp);
393 393 }
394 394 mutex_enter(&tp->tn_tlock);
395 395 tp->tn_nlink = 0;
396 396 mutex_exit(&tp->tn_tlock);
397 397 gethrestime(&tp->tn_ctime);
398 398 rw_exit(&tp->tn_rwlock);
399 399 tmpnode_rele(tp);
400 400 tp = NULL;
401 401 }
402 402 } else if (tpp) {
403 403 *tpp = tp;
404 404 } else if (op == DE_CREATE || op == DE_MKDIR) {
405 405 tmpnode_rele(tp);
406 406 }
407 407 }
408 408
409 409 out:
410 410 if (error && (op == DE_LINK || op == DE_RENAME)) {
411 411 /*
412 412 * Undo bumped link count.
413 413 */
414 414 DECR_COUNT(&tp->tn_nlink, &tp->tn_tlock);
415 415 gethrestime(&tp->tn_ctime);
416 416 }
417 417 return (error);
418 418 }
419 419
420 420 /*
421 421 * Delete entry tp of name "nm" from dir.
422 422 * Free dir entry space and decrement link count on tmpnode(s).
423 423 *
424 424 * Return 0 on success.
425 425 */
426 426 int
427 427 tdirdelete(
428 428 struct tmpnode *dir,
429 429 struct tmpnode *tp,
430 430 char *nm,
431 431 enum dr_op op,
432 432 struct cred *cred)
433 433 {
434 434 struct tdirent *tpdp;
435 435 int error;
436 436 size_t namelen;
437 437 struct tmpnode *tnp;
438 438 timestruc_t now;
439 439
440 440 ASSERT(RW_WRITE_HELD(&dir->tn_rwlock));
441 441 ASSERT(RW_WRITE_HELD(&tp->tn_rwlock));
442 442 ASSERT(dir->tn_type == VDIR);
443 443
444 444 if (nm[0] == '\0')
445 445 panic("tdirdelete: NULL name for %p", (void *)tp);
446 446
447 447 /*
448 448 * return error when removing . and ..
449 449 */
450 450 if (nm[0] == '.') {
451 451 if (nm[1] == '\0')
452 452 return (EINVAL);
453 453 if (nm[1] == '.' && nm[2] == '\0')
454 454 return (EEXIST); /* thus in ufs */
455 455 }
456 456
457 457 if (error = tmp_taccess(dir, VEXEC|VWRITE, cred))
458 458 return (error);
459 459
460 460 /*
461 461 * If the parent directory is "sticky", then the user must
462 462 * own the parent directory or the file in it, or else must
463 463 * have permission to write the file. Otherwise it may not
464 464 * be deleted (except by privileged users).
465 465 * Same as ufs_dirremove.
466 466 */
467 467 if ((error = tmp_sticky_remove_access(dir, tp, cred)) != 0)
468 468 return (error);
469 469
470 470 if (dir->tn_dir == NULL)
471 471 return (ENOENT);
472 472
473 473 tpdp = tmpfs_hash_lookup(nm, dir, 0, &tnp);
474 474 if (tpdp == NULL) {
475 475 /*
476 476 * If it is gone, some other thread got here first!
477 477 * Return error ENOENT.
478 478 */
479 479 return (ENOENT);
|
↓ open down ↓ |
442 lines elided |
↑ open up ↑ |
480 480 }
481 481
482 482 /*
483 483 * If the tmpnode in the tdirent changed, we were probably
484 484 * the victim of a concurrent rename operation. The original
485 485 * is gone, so return that status (same as UFS).
486 486 */
487 487 if (tp != tnp)
488 488 return (ENOENT);
489 489
490 + /*
491 + * If we are unlinking a directory which isn't empty (it has
492 + * more than the minumum '.' and '..' entries) return EEXIST.
493 + */
494 + if (tp->tn_type == VDIR && tp->tn_dirents > 2)
495 + return (EEXIST);
496 +
490 497 tmpfs_hash_out(tpdp);
491 498
492 499 /*
493 500 * Take tpdp out of the directory list.
494 501 */
495 502 ASSERT(tpdp->td_next != tpdp);
496 503 ASSERT(tpdp->td_prev != tpdp);
497 504 if (tpdp->td_prev) {
498 505 tpdp->td_prev->td_next = tpdp->td_next;
499 506 }
500 507 if (tpdp->td_next) {
501 508 tpdp->td_next->td_prev = tpdp->td_prev;
502 509 }
503 510
504 511 /*
505 512 * If the roving slot pointer happens to match tpdp,
506 513 * point it at the previous dirent.
507 514 */
508 515 if (dir->tn_dir->td_prev == tpdp) {
509 516 dir->tn_dir->td_prev = tpdp->td_prev;
510 517 }
511 518 ASSERT(tpdp->td_next != tpdp);
512 519 ASSERT(tpdp->td_prev != tpdp);
513 520
514 521 /*
515 522 * tpdp points to the correct directory entry
516 523 */
517 524 namelen = strlen(tpdp->td_name) + 1;
518 525
519 526 tmp_memfree(tpdp, sizeof (struct tdirent) + namelen);
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
520 527 dir->tn_size -= (sizeof (struct tdirent) + namelen);
521 528 dir->tn_dirents--;
522 529
523 530 gethrestime(&now);
524 531 dir->tn_mtime = now;
525 532 dir->tn_ctime = now;
526 533 tp->tn_ctime = now;
527 534
528 535 ASSERT(tp->tn_nlink > 0);
529 536 DECR_COUNT(&tp->tn_nlink, &tp->tn_tlock);
530 - if (op == DR_RMDIR && tp->tn_type == VDIR) {
537 + if (tp->tn_type == VDIR) {
531 538 tdirtrunc(tp);
532 539 ASSERT(tp->tn_nlink == 0);
533 540 }
534 541 return (0);
535 542 }
536 543
537 544 /*
538 545 * tdirinit is used internally to initialize a directory (dir)
539 546 * with '.' and '..' entries without checking permissions and locking
540 547 */
541 548 void
542 549 tdirinit(
543 550 struct tmpnode *parent, /* parent of directory to initialize */
544 551 struct tmpnode *dir) /* the new directory */
545 552 {
546 553 struct tdirent *dot, *dotdot;
547 554 timestruc_t now;
548 555
549 556 ASSERT(RW_WRITE_HELD(&parent->tn_rwlock));
550 557 ASSERT(dir->tn_type == VDIR);
551 558
552 559 dot = tmp_memalloc(sizeof (struct tdirent) + 2, TMP_MUSTHAVE);
553 560 dotdot = tmp_memalloc(sizeof (struct tdirent) + 3, TMP_MUSTHAVE);
554 561
555 562 /*
556 563 * Initialize the entries
557 564 */
558 565 dot->td_tmpnode = dir;
559 566 dot->td_offset = 0;
560 567 dot->td_name = (char *)dot + sizeof (struct tdirent);
561 568 dot->td_name[0] = '.';
562 569 dot->td_parent = dir;
563 570 tmpfs_hash_in(dot);
564 571
565 572 dotdot->td_tmpnode = parent;
566 573 dotdot->td_offset = 1;
567 574 dotdot->td_name = (char *)dotdot + sizeof (struct tdirent);
568 575 dotdot->td_name[0] = '.';
569 576 dotdot->td_name[1] = '.';
570 577 dotdot->td_parent = dir;
571 578 tmpfs_hash_in(dotdot);
572 579
573 580 /*
574 581 * Initialize directory entry list.
575 582 */
576 583 dot->td_next = dotdot;
577 584 dot->td_prev = dotdot; /* dot's td_prev holds roving slot pointer */
578 585 dotdot->td_next = NULL;
579 586 dotdot->td_prev = dot;
580 587
581 588 gethrestime(&now);
582 589 dir->tn_mtime = now;
583 590 dir->tn_ctime = now;
584 591
585 592 /*
586 593 * Link counts are special for the hidden attribute directory.
587 594 * The only explicit reference in the name space is "." and
588 595 * the reference through ".." is not counted on the parent
589 596 * file. The attrdir is created as a side effect to lookup,
590 597 * so don't change the ctime of the parent.
591 598 * Since tdirinit is called with both dir and parent being the
592 599 * same for the root vnode, we need to increment this before we set
593 600 * tn_nlink = 2 below.
594 601 */
595 602 if (!(dir->tn_vnode->v_flag & V_XATTRDIR)) {
596 603 INCR_COUNT(&parent->tn_nlink, &parent->tn_tlock);
597 604 parent->tn_ctime = now;
598 605 }
599 606
600 607 dir->tn_dir = dot;
601 608 dir->tn_size = 2 * sizeof (struct tdirent) + 5; /* dot and dotdot */
602 609 dir->tn_dirents = 2;
603 610 dir->tn_nlink = 2;
604 611 }
605 612
606 613
607 614 /*
608 615 * tdirtrunc is called to remove all directory entries under this directory.
609 616 */
610 617 void
611 618 tdirtrunc(struct tmpnode *dir)
612 619 {
613 620 struct tdirent *tdp;
614 621 struct tmpnode *tp;
615 622 size_t namelen;
616 623 timestruc_t now;
617 624 int isvattrdir, isdotdot, skip_decr;
618 625
619 626 ASSERT(RW_WRITE_HELD(&dir->tn_rwlock));
620 627 ASSERT(dir->tn_type == VDIR);
621 628
622 629 isvattrdir = (dir->tn_vnode->v_flag & V_XATTRDIR) ? 1 : 0;
623 630 for (tdp = dir->tn_dir; tdp; tdp = dir->tn_dir) {
624 631 ASSERT(tdp->td_next != tdp);
625 632 ASSERT(tdp->td_prev != tdp);
626 633 ASSERT(tdp->td_tmpnode);
627 634
628 635 dir->tn_dir = tdp->td_next;
629 636 namelen = strlen(tdp->td_name) + 1;
630 637
631 638 /*
632 639 * Adjust the link counts to account for this directory
633 640 * entry removal. Hidden attribute directories may
634 641 * not be empty as they may be truncated as a side-
635 642 * effect of removing the parent. We do hold/rele
636 643 * operations to free up these tmpnodes.
637 644 *
638 645 * Skip the link count adjustment for parents of
639 646 * attribute directories as those link counts
640 647 * do not include the ".." reference in the hidden
641 648 * directories.
642 649 */
643 650 tp = tdp->td_tmpnode;
644 651 isdotdot = (strcmp("..", tdp->td_name) == 0);
645 652 skip_decr = (isvattrdir && isdotdot);
646 653 if (!skip_decr) {
647 654 ASSERT(tp->tn_nlink > 0);
648 655 DECR_COUNT(&tp->tn_nlink, &tp->tn_tlock);
649 656 }
650 657
651 658 tmpfs_hash_out(tdp);
652 659
653 660 tmp_memfree(tdp, sizeof (struct tdirent) + namelen);
654 661 dir->tn_size -= (sizeof (struct tdirent) + namelen);
655 662 dir->tn_dirents--;
656 663 }
657 664
658 665 gethrestime(&now);
659 666 dir->tn_mtime = now;
660 667 dir->tn_ctime = now;
661 668
662 669 ASSERT(dir->tn_dir == NULL);
663 670 ASSERT(dir->tn_size == 0);
664 671 ASSERT(dir->tn_dirents == 0);
665 672 }
666 673
667 674 /*
668 675 * Check if the source directory is in the path of the target directory.
669 676 * The target directory is locked by the caller.
670 677 *
671 678 * XXX - The source and target's should be different upon entry.
672 679 */
673 680 static int
674 681 tdircheckpath(
675 682 struct tmpnode *fromtp,
676 683 struct tmpnode *toparent,
677 684 struct cred *cred)
678 685 {
679 686 int error = 0;
680 687 struct tmpnode *dir, *dotdot;
681 688 struct tdirent *tdp;
682 689
683 690 ASSERT(RW_WRITE_HELD(&toparent->tn_rwlock));
684 691
685 692 tdp = tmpfs_hash_lookup("..", toparent, 1, &dotdot);
686 693 if (tdp == NULL)
687 694 return (ENOENT);
688 695
689 696 ASSERT(dotdot);
690 697
691 698 if (dotdot == toparent) {
692 699 /* root of fs. search trivially satisfied. */
693 700 tmpnode_rele(dotdot);
694 701 return (0);
695 702 }
696 703 for (;;) {
697 704 /*
698 705 * Return error for cases like "mv c c/d",
699 706 * "mv c c/d/e" and so on.
700 707 */
701 708 if (dotdot == fromtp) {
702 709 tmpnode_rele(dotdot);
703 710 error = EINVAL;
704 711 break;
705 712 }
706 713 dir = dotdot;
707 714 error = tdirlookup(dir, "..", &dotdot, cred);
708 715 if (error) {
709 716 tmpnode_rele(dir);
710 717 break;
711 718 }
712 719 /*
713 720 * We're okay if we traverse the directory tree up to
714 721 * the root directory and don't run into the
715 722 * parent directory.
716 723 */
717 724 if (dir == dotdot) {
718 725 tmpnode_rele(dir);
719 726 tmpnode_rele(dotdot);
720 727 break;
721 728 }
722 729 tmpnode_rele(dir);
723 730 }
724 731 return (error);
725 732 }
726 733
727 734 static int
728 735 tdirrename(
729 736 struct tmpnode *fromparent, /* parent directory of source */
730 737 struct tmpnode *fromtp, /* source tmpnode */
731 738 struct tmpnode *toparent, /* parent directory of target */
732 739 char *nm, /* entry we are trying to change */
733 740 struct tmpnode *to, /* target tmpnode */
734 741 struct tdirent *where, /* target tmpnode directory entry */
735 742 struct cred *cred) /* credentials */
736 743 {
737 744 int error = 0;
738 745 int doingdirectory;
739 746 timestruc_t now;
740 747
741 748 #if defined(lint)
742 749 nm = nm;
743 750 #endif
744 751 ASSERT(RW_WRITE_HELD(&toparent->tn_rwlock));
745 752
746 753 /*
747 754 * Short circuit rename of something to itself.
748 755 */
749 756 if (fromtp == to)
750 757 return (ESAME); /* special KLUDGE error code */
751 758
752 759 rw_enter(&fromtp->tn_rwlock, RW_READER);
753 760 rw_enter(&to->tn_rwlock, RW_READER);
754 761
755 762 /*
756 763 * Check that everything is on the same filesystem.
757 764 */
758 765 if (to->tn_vnode->v_vfsp != toparent->tn_vnode->v_vfsp ||
759 766 to->tn_vnode->v_vfsp != fromtp->tn_vnode->v_vfsp) {
760 767 error = EXDEV;
761 768 goto out;
762 769 }
763 770
764 771 /*
765 772 * Must have write permission to rewrite target entry.
766 773 * Check for stickyness.
767 774 */
768 775 if ((error = tmp_taccess(toparent, VWRITE, cred)) != 0 ||
769 776 (error = tmp_sticky_remove_access(toparent, to, cred)) != 0)
770 777 goto out;
771 778
772 779 /*
773 780 * Ensure source and target are compatible (both directories
774 781 * or both not directories). If target is a directory it must
775 782 * be empty and have no links to it; in addition it must not
776 783 * be a mount point, and both the source and target must be
777 784 * writable.
778 785 */
779 786 doingdirectory = (fromtp->tn_type == VDIR);
780 787 if (to->tn_type == VDIR) {
781 788 if (!doingdirectory) {
782 789 error = EISDIR;
783 790 goto out;
784 791 }
785 792 /*
786 793 * vn_vfswlock will prevent mounts from using the directory
787 794 * until we are done.
788 795 */
789 796 if (vn_vfswlock(TNTOV(to))) {
790 797 error = EBUSY;
791 798 goto out;
792 799 }
793 800 if (vn_mountedvfs(TNTOV(to)) != NULL) {
794 801 vn_vfsunlock(TNTOV(to));
795 802 error = EBUSY;
796 803 goto out;
797 804 }
798 805
799 806 mutex_enter(&to->tn_tlock);
800 807 if (to->tn_dirents > 2 || to->tn_nlink > 2) {
801 808 mutex_exit(&to->tn_tlock);
802 809 vn_vfsunlock(TNTOV(to));
803 810 error = EEXIST; /* SIGH should be ENOTEMPTY */
804 811 /*
805 812 * Update atime because checking tn_dirents is
806 813 * logically equivalent to reading the directory
807 814 */
808 815 gethrestime(&to->tn_atime);
809 816 goto out;
810 817 }
811 818 mutex_exit(&to->tn_tlock);
812 819 } else if (doingdirectory) {
813 820 error = ENOTDIR;
814 821 goto out;
815 822 }
816 823
817 824 tmpfs_hash_change(where, fromtp);
818 825 gethrestime(&now);
819 826 toparent->tn_mtime = now;
820 827 toparent->tn_ctime = now;
821 828
822 829 /*
823 830 * Upgrade to write lock on "to" (i.e., the target tmpnode).
824 831 */
825 832 rw_exit(&to->tn_rwlock);
826 833 rw_enter(&to->tn_rwlock, RW_WRITER);
827 834
828 835 /*
829 836 * Decrement the link count of the target tmpnode.
830 837 */
831 838 DECR_COUNT(&to->tn_nlink, &to->tn_tlock);
832 839 to->tn_ctime = now;
833 840
834 841 if (doingdirectory) {
835 842 /*
836 843 * The entry for "to" no longer exists so release the vfslock.
837 844 */
838 845 vn_vfsunlock(TNTOV(to));
839 846
840 847 /*
841 848 * Decrement the target link count and delete all entires.
842 849 */
843 850 tdirtrunc(to);
844 851 ASSERT(to->tn_nlink == 0);
845 852
846 853 /*
847 854 * Renaming a directory with the parent different
848 855 * requires that ".." be rewritten. The window is
849 856 * still there for ".." to be inconsistent, but this
850 857 * is unavoidable, and a lot shorter than when it was
851 858 * done in a user process.
852 859 */
853 860 if (fromparent != toparent)
854 861 tdirfixdotdot(fromtp, fromparent, toparent);
855 862 }
856 863 out:
857 864 rw_exit(&to->tn_rwlock);
858 865 rw_exit(&fromtp->tn_rwlock);
859 866 return (error);
860 867 }
861 868
862 869 static void
863 870 tdirfixdotdot(
864 871 struct tmpnode *fromtp, /* child directory */
865 872 struct tmpnode *fromparent, /* old parent directory */
866 873 struct tmpnode *toparent) /* new parent directory */
867 874 {
868 875 struct tdirent *dotdot;
869 876
870 877 ASSERT(RW_LOCK_HELD(&toparent->tn_rwlock));
871 878
872 879 /*
873 880 * Increment the link count in the new parent tmpnode
874 881 */
875 882 INCR_COUNT(&toparent->tn_nlink, &toparent->tn_tlock);
876 883 gethrestime(&toparent->tn_ctime);
877 884
878 885 dotdot = tmpfs_hash_lookup("..", fromtp, 0, NULL);
879 886
880 887 ASSERT(dotdot->td_tmpnode == fromparent);
881 888 dotdot->td_tmpnode = toparent;
882 889
883 890 /*
884 891 * Decrement the link count of the old parent tmpnode.
885 892 * If fromparent is NULL, then this is a new directory link;
886 893 * it has no parent, so we need not do anything.
887 894 */
888 895 if (fromparent != NULL) {
889 896 mutex_enter(&fromparent->tn_tlock);
890 897 if (fromparent->tn_nlink != 0) {
891 898 fromparent->tn_nlink--;
892 899 gethrestime(&fromparent->tn_ctime);
893 900 }
894 901 mutex_exit(&fromparent->tn_tlock);
895 902 }
896 903 }
897 904
898 905 static int
899 906 tdiraddentry(
900 907 struct tmpnode *dir, /* target directory to make entry in */
901 908 struct tmpnode *tp, /* new tmpnode */
902 909 char *name,
903 910 enum de_op op,
904 911 struct tmpnode *fromtp)
905 912 {
906 913 struct tdirent *tdp, *tpdp;
907 914 size_t namelen, alloc_size;
908 915 timestruc_t now;
909 916
910 917 /*
911 918 * Make sure the parent directory wasn't removed from
912 919 * underneath the caller.
913 920 */
914 921 if (dir->tn_dir == NULL)
915 922 return (ENOENT);
916 923
917 924 /*
918 925 * Check that everything is on the same filesystem.
919 926 */
920 927 if (tp->tn_vnode->v_vfsp != dir->tn_vnode->v_vfsp)
921 928 return (EXDEV);
922 929
923 930 /*
924 931 * Allocate and initialize directory entry
925 932 */
926 933 namelen = strlen(name) + 1;
927 934 alloc_size = namelen + sizeof (struct tdirent);
928 935 tdp = tmp_memalloc(alloc_size, 0);
929 936 if (tdp == NULL)
930 937 return (ENOSPC);
931 938
932 939 if ((op == DE_RENAME) && (tp->tn_type == VDIR))
933 940 tdirfixdotdot(tp, fromtp, dir);
934 941
935 942 dir->tn_size += alloc_size;
936 943 dir->tn_dirents++;
937 944 tdp->td_tmpnode = tp;
938 945 tdp->td_parent = dir;
939 946
940 947 /*
941 948 * The directory entry and its name were allocated sequentially.
942 949 */
943 950 tdp->td_name = (char *)tdp + sizeof (struct tdirent);
944 951 (void) strcpy(tdp->td_name, name);
945 952
946 953 tmpfs_hash_in(tdp);
947 954
948 955 /*
949 956 * Some utilities expect the size of a directory to remain
950 957 * somewhat static. For example, a routine which unlinks
951 958 * files between calls to readdir(); the size of the
952 959 * directory changes from underneath it and so the real
953 960 * directory offset in bytes is invalid. To circumvent
954 961 * this problem, we initialize a directory entry with an
955 962 * phony offset, and use this offset to determine end of
956 963 * file in tmp_readdir.
957 964 */
958 965 tpdp = dir->tn_dir->td_prev;
959 966 /*
960 967 * Install at first empty "slot" in directory list.
961 968 */
962 969 while (tpdp->td_next != NULL && (tpdp->td_next->td_offset -
963 970 tpdp->td_offset) <= 1) {
964 971 ASSERT(tpdp->td_next != tpdp);
965 972 ASSERT(tpdp->td_prev != tpdp);
966 973 ASSERT(tpdp->td_next->td_offset > tpdp->td_offset);
967 974 tpdp = tpdp->td_next;
968 975 }
969 976 tdp->td_offset = tpdp->td_offset + 1;
970 977
971 978 /*
972 979 * If we're at the end of the dirent list and the offset (which
973 980 * is necessarily the largest offset in this directory) is more
974 981 * than twice the number of dirents, that means the directory is
975 982 * 50% holes. At this point we reset the slot pointer back to
976 983 * the beginning of the directory so we start using the holes.
977 984 * The idea is that if there are N dirents, there must also be
978 985 * N holes, so we can satisfy the next N creates by walking at
979 986 * most 2N entries; thus the average cost of a create is constant.
980 987 * Note that we use the first dirent's td_prev as the roving
981 988 * slot pointer; it's ugly, but it saves a word in every dirent.
982 989 */
983 990 if (tpdp->td_next == NULL && tpdp->td_offset > 2 * dir->tn_dirents)
984 991 dir->tn_dir->td_prev = dir->tn_dir->td_next;
985 992 else
986 993 dir->tn_dir->td_prev = tdp;
987 994
988 995 ASSERT(tpdp->td_next != tpdp);
989 996 ASSERT(tpdp->td_prev != tpdp);
990 997
991 998 tdp->td_next = tpdp->td_next;
992 999 if (tdp->td_next) {
993 1000 tdp->td_next->td_prev = tdp;
994 1001 }
995 1002 tdp->td_prev = tpdp;
996 1003 tpdp->td_next = tdp;
997 1004
998 1005 ASSERT(tdp->td_next != tdp);
999 1006 ASSERT(tdp->td_prev != tdp);
1000 1007 ASSERT(tpdp->td_next != tpdp);
1001 1008 ASSERT(tpdp->td_prev != tpdp);
1002 1009
1003 1010 gethrestime(&now);
1004 1011 dir->tn_mtime = now;
1005 1012 dir->tn_ctime = now;
1006 1013
1007 1014 return (0);
1008 1015 }
1009 1016
1010 1017 static int
1011 1018 tdirmaketnode(
1012 1019 struct tmpnode *dir,
1013 1020 struct tmount *tm,
1014 1021 struct vattr *va,
1015 1022 enum de_op op,
1016 1023 struct tmpnode **newnode,
1017 1024 struct cred *cred)
1018 1025 {
1019 1026 struct tmpnode *tp;
1020 1027 enum vtype type;
1021 1028
1022 1029 ASSERT(va != NULL);
1023 1030 ASSERT(op == DE_CREATE || op == DE_MKDIR);
1024 1031 if (((va->va_mask & AT_ATIME) && TIMESPEC_OVERFLOW(&va->va_atime)) ||
1025 1032 ((va->va_mask & AT_MTIME) && TIMESPEC_OVERFLOW(&va->va_mtime)))
1026 1033 return (EOVERFLOW);
1027 1034 type = va->va_type;
1028 1035 tp = tmp_memalloc(sizeof (struct tmpnode), TMP_MUSTHAVE);
1029 1036 tmpnode_init(tm, tp, va, cred);
1030 1037
1031 1038 /* setup normal file/dir's extended attribute directory */
1032 1039 if (dir->tn_flags & ISXATTR) {
1033 1040 /* parent dir is , mark file as xattr */
1034 1041 tp->tn_flags |= ISXATTR;
1035 1042 }
1036 1043
1037 1044
1038 1045 if (type == VBLK || type == VCHR) {
1039 1046 tp->tn_vnode->v_rdev = tp->tn_rdev = va->va_rdev;
1040 1047 } else {
1041 1048 tp->tn_vnode->v_rdev = tp->tn_rdev = NODEV;
1042 1049 }
1043 1050 tp->tn_vnode->v_type = type;
1044 1051 tp->tn_uid = crgetuid(cred);
1045 1052
1046 1053 /*
1047 1054 * To determine the group-id of the created file:
1048 1055 * 1) If the gid is set in the attribute list (non-Sun & pre-4.0
1049 1056 * clients are not likely to set the gid), then use it if
1050 1057 * the process is privileged, belongs to the target group,
1051 1058 * or the group is the same as the parent directory.
1052 1059 * 2) If the filesystem was not mounted with the Old-BSD-compatible
1053 1060 * GRPID option, and the directory's set-gid bit is clear,
1054 1061 * then use the process's gid.
1055 1062 * 3) Otherwise, set the group-id to the gid of the parent directory.
1056 1063 */
1057 1064 if ((va->va_mask & AT_GID) &&
1058 1065 ((va->va_gid == dir->tn_gid) || groupmember(va->va_gid, cred) ||
1059 1066 secpolicy_vnode_create_gid(cred) == 0)) {
1060 1067 /*
1061 1068 * XXX - is this only the case when a 4.0 NFS client, or a
1062 1069 * client derived from that code, makes a call over the wire?
1063 1070 */
1064 1071 tp->tn_gid = va->va_gid;
1065 1072 } else {
1066 1073 if (dir->tn_mode & VSGID)
1067 1074 tp->tn_gid = dir->tn_gid;
1068 1075 else
1069 1076 tp->tn_gid = crgetgid(cred);
1070 1077 }
1071 1078 /*
1072 1079 * If we're creating a directory, and the parent directory has the
1073 1080 * set-GID bit set, set it on the new directory.
1074 1081 * Otherwise, if the user is neither privileged nor a member of the
1075 1082 * file's new group, clear the file's set-GID bit.
1076 1083 */
1077 1084 if (dir->tn_mode & VSGID && type == VDIR)
1078 1085 tp->tn_mode |= VSGID;
1079 1086 else {
1080 1087 if ((tp->tn_mode & VSGID) &&
1081 1088 secpolicy_vnode_setids_setgids(cred, tp->tn_gid) != 0)
1082 1089 tp->tn_mode &= ~VSGID;
1083 1090 }
1084 1091
1085 1092 if (va->va_mask & AT_ATIME)
1086 1093 tp->tn_atime = va->va_atime;
1087 1094 if (va->va_mask & AT_MTIME)
1088 1095 tp->tn_mtime = va->va_mtime;
1089 1096
1090 1097 if (op == DE_MKDIR)
1091 1098 tdirinit(dir, tp);
1092 1099
1093 1100 *newnode = tp;
1094 1101 return (0);
1095 1102 }
|
↓ open down ↓ |
555 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX