1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2017 Red Hat, Inc. 4 */ 5 6 #include <linux/cred.h> 7 #include <linux/file.h> 8 #include <linux/mount.h> 9 #include <linux/xattr.h> 10 #include <linux/uio.h> 11 #include <linux/uaccess.h> 12 #include <linux/splice.h> 13 #include <linux/mm.h> 14 #include <linux/fs.h> 15 #include "overlayfs.h" 16 17 struct ovl_aio_req { 18 struct kiocb iocb; 19 struct kiocb *orig_iocb; 20 struct fd fd; 21 }; 22 23 static struct kmem_cache *ovl_aio_request_cachep; 24 25 static char ovl_whatisit(struct inode *inode, struct inode *realinode) 26 { 27 if (realinode != ovl_inode_upper(inode)) 28 return 'l'; 29 if (ovl_has_upperdata(inode)) 30 return 'u'; 31 else 32 return 'm'; 33 } 34 35 static struct file *ovl_open_realfile(const struct file *file, 36 struct inode *realinode) 37 { 38 struct inode *inode = file_inode(file); 39 struct file *realfile; 40 const struct cred *old_cred; 41 int flags = file->f_flags | O_NOATIME | FMODE_NONOTIFY; 42 43 old_cred = ovl_override_creds(inode->i_sb); 44 realfile = open_with_fake_path(&file->f_path, flags, realinode, 45 current_cred()); 46 revert_creds(old_cred); 47 48 pr_debug("open(%p[%pD2/%c], 0%o) -> (%p, 0%o)\n", 49 file, file, ovl_whatisit(inode, realinode), file->f_flags, 50 realfile, IS_ERR(realfile) ? 0 : realfile->f_flags); 51 52 return realfile; 53 } 54 55 #define OVL_SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT) 56 57 static int ovl_change_flags(struct file *file, unsigned int flags) 58 { 59 struct inode *inode = file_inode(file); 60 int err; 61 62 /* No atime modificaton on underlying */ 63 flags |= O_NOATIME | FMODE_NONOTIFY; 64 65 /* If some flag changed that cannot be changed then something's amiss */ 66 if (WARN_ON((file->f_flags ^ flags) & ~OVL_SETFL_MASK)) 67 return -EIO; 68 69 flags &= OVL_SETFL_MASK; 70 71 if (((flags ^ file->f_flags) & O_APPEND) && IS_APPEND(inode)) 72 return -EPERM; 73 74 if (flags & O_DIRECT) { 75 if (!file->f_mapping->a_ops || 76 !file->f_mapping->a_ops->direct_IO) 77 return -EINVAL; 78 } 79 80 if (file->f_op->check_flags) { 81 err = file->f_op->check_flags(flags); 82 if (err) 83 return err; 84 } 85 86 spin_lock(&file->f_lock); 87 file->f_flags = (file->f_flags & ~OVL_SETFL_MASK) | flags; 88 spin_unlock(&file->f_lock); 89 90 return 0; 91 } 92 93 static int ovl_real_fdget_meta(const struct file *file, struct fd *real, 94 bool allow_meta) 95 { 96 struct inode *inode = file_inode(file); 97 struct inode *realinode; 98 99 real->flags = 0; 100 real->file = file->private_data; 101 102 if (allow_meta) 103 realinode = ovl_inode_real(inode); 104 else 105 realinode = ovl_inode_realdata(inode); 106 107 /* Has it been copied up since we'd opened it? */ 108 if (unlikely(file_inode(real->file) != realinode)) { 109 real->flags = FDPUT_FPUT; 110 real->file = ovl_open_realfile(file, realinode); 111 112 return PTR_ERR_OR_ZERO(real->file); 113 } 114 115 /* Did the flags change since open? */ 116 if (unlikely((file->f_flags ^ real->file->f_flags) & ~O_NOATIME)) 117 return ovl_change_flags(real->file, file->f_flags); 118 119 return 0; 120 } 121 122 static int ovl_real_fdget(const struct file *file, struct fd *real) 123 { 124 return ovl_real_fdget_meta(file, real, false); 125 } 126 127 static int ovl_open(struct inode *inode, struct file *file) 128 { 129 struct file *realfile; 130 int err; 131 132 err = ovl_maybe_copy_up(file_dentry(file), file->f_flags); 133 if (err) 134 return err; 135 136 /* No longer need these flags, so don't pass them on to underlying fs */ 137 file->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); 138 139 realfile = ovl_open_realfile(file, ovl_inode_realdata(inode)); 140 if (IS_ERR(realfile)) 141 return PTR_ERR(realfile); 142 143 file->private_data = realfile; 144 145 return 0; 146 } 147 148 static int ovl_release(struct inode *inode, struct file *file) 149 { 150 fput(file->private_data); 151 152 return 0; 153 } 154 155 static loff_t ovl_llseek(struct file *file, loff_t offset, int whence) 156 { 157 struct inode *inode = file_inode(file); 158 struct fd real; 159 const struct cred *old_cred; 160 loff_t ret; 161 162 /* 163 * The two special cases below do not need to involve real fs, 164 * so we can optimizing concurrent callers. 165 */ 166 if (offset == 0) { 167 if (whence == SEEK_CUR) 168 return file->f_pos; 169 170 if (whence == SEEK_SET) 171 return vfs_setpos(file, 0, 0); 172 } 173 174 ret = ovl_real_fdget(file, &real); 175 if (ret) 176 return ret; 177 178 /* 179 * Overlay file f_pos is the master copy that is preserved 180 * through copy up and modified on read/write, but only real 181 * fs knows how to SEEK_HOLE/SEEK_DATA and real fs may impose 182 * limitations that are more strict than ->s_maxbytes for specific 183 * files, so we use the real file to perform seeks. 184 */ 185 ovl_inode_lock(inode); 186 real.file->f_pos = file->f_pos; 187 188 old_cred = ovl_override_creds(inode->i_sb); 189 ret = vfs_llseek(real.file, offset, whence); 190 revert_creds(old_cred); 191 192 file->f_pos = real.file->f_pos; 193 ovl_inode_unlock(inode); 194 195 fdput(real); 196 197 return ret; 198 } 199 200 static void ovl_file_accessed(struct file *file) 201 { 202 struct inode *inode, *upperinode; 203 204 if (file->f_flags & O_NOATIME) 205 return; 206 207 inode = file_inode(file); 208 upperinode = ovl_inode_upper(inode); 209 210 if (!upperinode) 211 return; 212 213 if ((!timespec64_equal(&inode->i_mtime, &upperinode->i_mtime) || 214 !timespec64_equal(&inode->i_ctime, &upperinode->i_ctime))) { 215 inode->i_mtime = upperinode->i_mtime; 216 inode->i_ctime = upperinode->i_ctime; 217 } 218 219 touch_atime(&file->f_path); 220 } 221 222 static rwf_t ovl_iocb_to_rwf(struct kiocb *iocb) 223 { 224 int ifl = iocb->ki_flags; 225 rwf_t flags = 0; 226 227 if (ifl & IOCB_NOWAIT) 228 flags |= RWF_NOWAIT; 229 if (ifl & IOCB_HIPRI) 230 flags |= RWF_HIPRI; 231 if (ifl & IOCB_DSYNC) 232 flags |= RWF_DSYNC; 233 if (ifl & IOCB_SYNC) 234 flags |= RWF_SYNC; 235 236 return flags; 237 } 238 239 static void ovl_aio_cleanup_handler(struct ovl_aio_req *aio_req) 240 { 241 struct kiocb *iocb = &aio_req->iocb; 242 struct kiocb *orig_iocb = aio_req->orig_iocb; 243 244 if (iocb->ki_flags & IOCB_WRITE) { 245 struct inode *inode = file_inode(orig_iocb->ki_filp); 246 247 file_end_write(iocb->ki_filp); 248 ovl_copyattr(ovl_inode_real(inode), inode); 249 } 250 251 orig_iocb->ki_pos = iocb->ki_pos; 252 fdput(aio_req->fd); 253 kmem_cache_free(ovl_aio_request_cachep, aio_req); 254 } 255 256 static void ovl_aio_rw_complete(struct kiocb *iocb, long res, long res2) 257 { 258 struct ovl_aio_req *aio_req = container_of(iocb, 259 struct ovl_aio_req, iocb); 260 struct kiocb *orig_iocb = aio_req->orig_iocb; 261 262 ovl_aio_cleanup_handler(aio_req); 263 orig_iocb->ki_complete(orig_iocb, res, res2); 264 } 265 266 static ssize_t ovl_read_iter(struct kiocb *iocb, struct iov_iter *iter) 267 { 268 struct file *file = iocb->ki_filp; 269 struct fd real; 270 const struct cred *old_cred; 271 ssize_t ret; 272 273 if (!iov_iter_count(iter)) 274 return 0; 275 276 ret = ovl_real_fdget(file, &real); 277 if (ret) 278 return ret; 279 280 old_cred = ovl_override_creds(file_inode(file)->i_sb); 281 if (is_sync_kiocb(iocb)) { 282 ret = vfs_iter_read(real.file, iter, &iocb->ki_pos, 283 ovl_iocb_to_rwf(iocb)); 284 } else { 285 struct ovl_aio_req *aio_req; 286 287 ret = -ENOMEM; 288 aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL); 289 if (!aio_req) 290 goto out; 291 292 aio_req->fd = real; 293 real.flags = 0; 294 aio_req->orig_iocb = iocb; 295 kiocb_clone(&aio_req->iocb, iocb, real.file); 296 aio_req->iocb.ki_complete = ovl_aio_rw_complete; 297 ret = vfs_iocb_iter_read(real.file, &aio_req->iocb, iter); 298 if (ret != -EIOCBQUEUED) 299 ovl_aio_cleanup_handler(aio_req); 300 } 301 out: 302 revert_creds(old_cred); 303 ovl_file_accessed(file); 304 305 fdput(real); 306 307 return ret; 308 } 309 310 static ssize_t ovl_write_iter(struct kiocb *iocb, struct iov_iter *iter) 311 { 312 struct file *file = iocb->ki_filp; 313 struct inode *inode = file_inode(file); 314 struct fd real; 315 const struct cred *old_cred; 316 ssize_t ret; 317 318 if (!iov_iter_count(iter)) 319 return 0; 320 321 inode_lock(inode); 322 /* Update mode */ 323 ovl_copyattr(ovl_inode_real(inode), inode); 324 ret = file_remove_privs(file); 325 if (ret) 326 goto out_unlock; 327 328 ret = ovl_real_fdget(file, &real); 329 if (ret) 330 goto out_unlock; 331 332 old_cred = ovl_override_creds(file_inode(file)->i_sb); 333 if (is_sync_kiocb(iocb)) { 334 file_start_write(real.file); 335 ret = vfs_iter_write(real.file, iter, &iocb->ki_pos, 336 ovl_iocb_to_rwf(iocb)); 337 file_end_write(real.file); 338 /* Update size */ 339 ovl_copyattr(ovl_inode_real(inode), inode); 340 } else { 341 struct ovl_aio_req *aio_req; 342 343 ret = -ENOMEM; 344 aio_req = kmem_cache_zalloc(ovl_aio_request_cachep, GFP_KERNEL); 345 if (!aio_req) 346 goto out; 347 348 file_start_write(real.file); 349 aio_req->fd = real; 350 real.flags = 0; 351 aio_req->orig_iocb = iocb; 352 kiocb_clone(&aio_req->iocb, iocb, real.file); 353 aio_req->iocb.ki_complete = ovl_aio_rw_complete; 354 ret = vfs_iocb_iter_write(real.file, &aio_req->iocb, iter); 355 if (ret != -EIOCBQUEUED) 356 ovl_aio_cleanup_handler(aio_req); 357 } 358 out: 359 revert_creds(old_cred); 360 fdput(real); 361 362 out_unlock: 363 inode_unlock(inode); 364 365 return ret; 366 } 367 368 static ssize_t ovl_splice_read(struct file *in, loff_t *ppos, 369 struct pipe_inode_info *pipe, size_t len, 370 unsigned int flags) 371 { 372 ssize_t ret; 373 struct fd real; 374 const struct cred *old_cred; 375 376 ret = ovl_real_fdget(in, &real); 377 if (ret) 378 return ret; 379 380 old_cred = ovl_override_creds(file_inode(in)->i_sb); 381 ret = generic_file_splice_read(real.file, ppos, pipe, len, flags); 382 revert_creds(old_cred); 383 384 ovl_file_accessed(in); 385 fdput(real); 386 return ret; 387 } 388 389 static ssize_t 390 ovl_splice_write(struct pipe_inode_info *pipe, struct file *out, 391 loff_t *ppos, size_t len, unsigned int flags) 392 { 393 struct fd real; 394 const struct cred *old_cred; 395 ssize_t ret; 396 397 ret = ovl_real_fdget(out, &real); 398 if (ret) 399 return ret; 400 401 old_cred = ovl_override_creds(file_inode(out)->i_sb); 402 ret = iter_file_splice_write(pipe, real.file, ppos, len, flags); 403 revert_creds(old_cred); 404 405 ovl_file_accessed(out); 406 fdput(real); 407 return ret; 408 } 409 410 static int ovl_fsync(struct file *file, loff_t start, loff_t end, int datasync) 411 { 412 struct fd real; 413 const struct cred *old_cred; 414 int ret; 415 416 ret = ovl_real_fdget_meta(file, &real, !datasync); 417 if (ret) 418 return ret; 419 420 /* Don't sync lower file for fear of receiving EROFS error */ 421 if (file_inode(real.file) == ovl_inode_upper(file_inode(file))) { 422 old_cred = ovl_override_creds(file_inode(file)->i_sb); 423 ret = vfs_fsync_range(real.file, start, end, datasync); 424 revert_creds(old_cred); 425 } 426 427 fdput(real); 428 429 return ret; 430 } 431 432 static int ovl_mmap(struct file *file, struct vm_area_struct *vma) 433 { 434 struct file *realfile = file->private_data; 435 const struct cred *old_cred; 436 int ret; 437 438 if (!realfile->f_op->mmap) 439 return -ENODEV; 440 441 if (WARN_ON(file != vma->vm_file)) 442 return -EIO; 443 444 vma->vm_file = get_file(realfile); 445 446 old_cred = ovl_override_creds(file_inode(file)->i_sb); 447 ret = call_mmap(vma->vm_file, vma); 448 revert_creds(old_cred); 449 450 if (ret) { 451 /* Drop reference count from new vm_file value */ 452 fput(realfile); 453 } else { 454 /* Drop reference count from previous vm_file value */ 455 fput(file); 456 } 457 458 ovl_file_accessed(file); 459 460 return ret; 461 } 462 463 static long ovl_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 464 { 465 struct inode *inode = file_inode(file); 466 struct fd real; 467 const struct cred *old_cred; 468 int ret; 469 470 ret = ovl_real_fdget(file, &real); 471 if (ret) 472 return ret; 473 474 old_cred = ovl_override_creds(file_inode(file)->i_sb); 475 ret = vfs_fallocate(real.file, mode, offset, len); 476 revert_creds(old_cred); 477 478 /* Update size */ 479 ovl_copyattr(ovl_inode_real(inode), inode); 480 481 fdput(real); 482 483 return ret; 484 } 485 486 static int ovl_fadvise(struct file *file, loff_t offset, loff_t len, int advice) 487 { 488 struct fd real; 489 const struct cred *old_cred; 490 int ret; 491 492 ret = ovl_real_fdget(file, &real); 493 if (ret) 494 return ret; 495 496 old_cred = ovl_override_creds(file_inode(file)->i_sb); 497 ret = vfs_fadvise(real.file, offset, len, advice); 498 revert_creds(old_cred); 499 500 fdput(real); 501 502 return ret; 503 } 504 505 static long ovl_real_ioctl(struct file *file, unsigned int cmd, 506 unsigned long arg) 507 { 508 struct fd real; 509 const struct cred *old_cred; 510 long ret; 511 512 ret = ovl_real_fdget(file, &real); 513 if (ret) 514 return ret; 515 516 old_cred = ovl_override_creds(file_inode(file)->i_sb); 517 ret = vfs_ioctl(real.file, cmd, arg); 518 revert_creds(old_cred); 519 520 fdput(real); 521 522 return ret; 523 } 524 525 static long ovl_ioctl_set_flags(struct file *file, unsigned int cmd, 526 unsigned long arg, unsigned int iflags) 527 { 528 long ret; 529 struct inode *inode = file_inode(file); 530 unsigned int old_iflags; 531 532 if (!inode_owner_or_capable(inode)) 533 return -EACCES; 534 535 ret = mnt_want_write_file(file); 536 if (ret) 537 return ret; 538 539 inode_lock(inode); 540 541 /* Check the capability before cred override */ 542 ret = -EPERM; 543 old_iflags = READ_ONCE(inode->i_flags); 544 if (((iflags ^ old_iflags) & (S_APPEND | S_IMMUTABLE)) && 545 !capable(CAP_LINUX_IMMUTABLE)) 546 goto unlock; 547 548 ret = ovl_maybe_copy_up(file_dentry(file), O_WRONLY); 549 if (ret) 550 goto unlock; 551 552 ret = ovl_real_ioctl(file, cmd, arg); 553 554 ovl_copyflags(ovl_inode_real(inode), inode); 555 unlock: 556 inode_unlock(inode); 557 558 mnt_drop_write_file(file); 559 560 return ret; 561 562 } 563 564 static unsigned int ovl_fsflags_to_iflags(unsigned int flags) 565 { 566 unsigned int iflags = 0; 567 568 if (flags & FS_SYNC_FL) 569 iflags |= S_SYNC; 570 if (flags & FS_APPEND_FL) 571 iflags |= S_APPEND; 572 if (flags & FS_IMMUTABLE_FL) 573 iflags |= S_IMMUTABLE; 574 if (flags & FS_NOATIME_FL) 575 iflags |= S_NOATIME; 576 577 return iflags; 578 } 579 580 static long ovl_ioctl_set_fsflags(struct file *file, unsigned int cmd, 581 unsigned long arg) 582 { 583 unsigned int flags; 584 585 if (get_user(flags, (int __user *) arg)) 586 return -EFAULT; 587 588 return ovl_ioctl_set_flags(file, cmd, arg, 589 ovl_fsflags_to_iflags(flags)); 590 } 591 592 static unsigned int ovl_fsxflags_to_iflags(unsigned int xflags) 593 { 594 unsigned int iflags = 0; 595 596 if (xflags & FS_XFLAG_SYNC) 597 iflags |= S_SYNC; 598 if (xflags & FS_XFLAG_APPEND) 599 iflags |= S_APPEND; 600 if (xflags & FS_XFLAG_IMMUTABLE) 601 iflags |= S_IMMUTABLE; 602 if (xflags & FS_XFLAG_NOATIME) 603 iflags |= S_NOATIME; 604 605 return iflags; 606 } 607 608 static long ovl_ioctl_set_fsxflags(struct file *file, unsigned int cmd, 609 unsigned long arg) 610 { 611 struct fsxattr fa; 612 613 memset(&fa, 0, sizeof(fa)); 614 if (copy_from_user(&fa, (void __user *) arg, sizeof(fa))) 615 return -EFAULT; 616 617 return ovl_ioctl_set_flags(file, cmd, arg, 618 ovl_fsxflags_to_iflags(fa.fsx_xflags)); 619 } 620 621 static long ovl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 622 { 623 long ret; 624 625 switch (cmd) { 626 case FS_IOC_GETFLAGS: 627 case FS_IOC_FSGETXATTR: 628 ret = ovl_real_ioctl(file, cmd, arg); 629 break; 630 631 case FS_IOC_SETFLAGS: 632 ret = ovl_ioctl_set_fsflags(file, cmd, arg); 633 break; 634 635 case FS_IOC_FSSETXATTR: 636 ret = ovl_ioctl_set_fsxflags(file, cmd, arg); 637 break; 638 639 default: 640 ret = -ENOTTY; 641 } 642 643 return ret; 644 } 645 646 static long ovl_compat_ioctl(struct file *file, unsigned int cmd, 647 unsigned long arg) 648 { 649 switch (cmd) { 650 case FS_IOC32_GETFLAGS: 651 cmd = FS_IOC_GETFLAGS; 652 break; 653 654 case FS_IOC32_SETFLAGS: 655 cmd = FS_IOC_SETFLAGS; 656 break; 657 658 default: 659 return -ENOIOCTLCMD; 660 } 661 662 return ovl_ioctl(file, cmd, arg); 663 } 664 665 enum ovl_copyop { 666 OVL_COPY, 667 OVL_CLONE, 668 OVL_DEDUPE, 669 }; 670 671 static loff_t ovl_copyfile(struct file *file_in, loff_t pos_in, 672 struct file *file_out, loff_t pos_out, 673 loff_t len, unsigned int flags, enum ovl_copyop op) 674 { 675 struct inode *inode_out = file_inode(file_out); 676 struct fd real_in, real_out; 677 const struct cred *old_cred; 678 loff_t ret; 679 680 ret = ovl_real_fdget(file_out, &real_out); 681 if (ret) 682 return ret; 683 684 ret = ovl_real_fdget(file_in, &real_in); 685 if (ret) { 686 fdput(real_out); 687 return ret; 688 } 689 690 old_cred = ovl_override_creds(file_inode(file_out)->i_sb); 691 switch (op) { 692 case OVL_COPY: 693 ret = vfs_copy_file_range(real_in.file, pos_in, 694 real_out.file, pos_out, len, flags); 695 break; 696 697 case OVL_CLONE: 698 ret = vfs_clone_file_range(real_in.file, pos_in, 699 real_out.file, pos_out, len, flags); 700 break; 701 702 case OVL_DEDUPE: 703 ret = vfs_dedupe_file_range_one(real_in.file, pos_in, 704 real_out.file, pos_out, len, 705 flags); 706 break; 707 } 708 revert_creds(old_cred); 709 710 /* Update size */ 711 ovl_copyattr(ovl_inode_real(inode_out), inode_out); 712 713 fdput(real_in); 714 fdput(real_out); 715 716 return ret; 717 } 718 719 static ssize_t ovl_copy_file_range(struct file *file_in, loff_t pos_in, 720 struct file *file_out, loff_t pos_out, 721 size_t len, unsigned int flags) 722 { 723 return ovl_copyfile(file_in, pos_in, file_out, pos_out, len, flags, 724 OVL_COPY); 725 } 726 727 static loff_t ovl_remap_file_range(struct file *file_in, loff_t pos_in, 728 struct file *file_out, loff_t pos_out, 729 loff_t len, unsigned int remap_flags) 730 { 731 enum ovl_copyop op; 732 733 if (remap_flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_ADVISORY)) 734 return -EINVAL; 735 736 if (remap_flags & REMAP_FILE_DEDUP) 737 op = OVL_DEDUPE; 738 else 739 op = OVL_CLONE; 740 741 /* 742 * Don't copy up because of a dedupe request, this wouldn't make sense 743 * most of the time (data would be duplicated instead of deduplicated). 744 */ 745 if (op == OVL_DEDUPE && 746 (!ovl_inode_upper(file_inode(file_in)) || 747 !ovl_inode_upper(file_inode(file_out)))) 748 return -EPERM; 749 750 return ovl_copyfile(file_in, pos_in, file_out, pos_out, len, 751 remap_flags, op); 752 } 753 754 const struct file_operations ovl_file_operations = { 755 .open = ovl_open, 756 .release = ovl_release, 757 .llseek = ovl_llseek, 758 .read_iter = ovl_read_iter, 759 .write_iter = ovl_write_iter, 760 .fsync = ovl_fsync, 761 .mmap = ovl_mmap, 762 .fallocate = ovl_fallocate, 763 .fadvise = ovl_fadvise, 764 .unlocked_ioctl = ovl_ioctl, 765 .compat_ioctl = ovl_compat_ioctl, 766 .splice_read = ovl_splice_read, 767 .splice_write = ovl_splice_write, 768 769 .copy_file_range = ovl_copy_file_range, 770 .remap_file_range = ovl_remap_file_range, 771 }; 772 773 int __init ovl_aio_request_cache_init(void) 774 { 775 ovl_aio_request_cachep = kmem_cache_create("ovl_aio_req", 776 sizeof(struct ovl_aio_req), 777 0, SLAB_HWCACHE_ALIGN, NULL); 778 if (!ovl_aio_request_cachep) 779 return -ENOMEM; 780 781 return 0; 782 } 783 784 void ovl_aio_request_cache_destroy(void) 785 { 786 kmem_cache_destroy(ovl_aio_request_cachep); 787 } 788