← Back to branch summary

~ubuntu-branches/debian/wheezy/zfsutils/wheezy

« back to all changes in this revision

Viewing changes to .pc/03_glibc_namespace.diff/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c

  • Committer: Package Import Robot
  • Author(s): Robert Millan, Robert Millan
  • Date: 2012-02-04 17:16:40 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20120204171640-zkmubmewnswspzku
Tags: 9.0-1
* New upstream release.

[ Robert Millan ]
* zfsutils.cron.daily: Fix to avoid listing children file systems'
  snapshots as candidates for removal.
* zfsutils.cron.daily: Remove verbose output.
* Remove X-Start-Before & X-Stop-After (no longer needed since ZVOL
  subsystem is not started by userland anymore).

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/03_glibc_namespace.diff/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_vnops.c
31
31
#include <sys/systm.h>
32
32
#include <sys/sysmacros.h>
33
33
#include <sys/resource.h>
34
 
#include <sys/resourcevar.h>
35
34
#include <sys/vfs.h>
36
35
#include <sys/vnode.h>
37
36
#include <sys/file.h>
326
325
        for (;;) {
327
326
                if ((pp = vm_page_lookup(obj, OFF_TO_IDX(start))) != NULL &&
328
327
                    vm_page_is_valid(pp, (vm_offset_t)off, nbytes)) {
329
 
                        if (vm_page_sleep_if_busy(pp, FALSE, "zfsmwb"))
 
328
                        if ((pp->oflags & VPO_BUSY) != 0) {
 
329
                                /*
 
330
                                 * Reference the page before unlocking and
 
331
                                 * sleeping so that the page daemon is less
 
332
                                 * likely to reclaim it.
 
333
                                 */
 
334
                                vm_page_reference(pp);
 
335
                                vm_page_sleep(pp, "zfsmwb");
330
336
                                continue;
 
337
                        }
331
338
                        vm_page_busy(pp);
332
 
                        vm_page_lock_queues();
333
339
                        vm_page_undirty(pp);
334
 
                        vm_page_unlock_queues();
335
340
                } else {
336
341
                        if (__predict_false(obj->cache != NULL)) {
337
342
                                vm_page_cache_free(obj, OFF_TO_IDX(start),
446
451
        for (start = uio->uio_loffset; len > 0; start += PAGESIZE) {
447
452
                int bytes = MIN(PAGESIZE, len);
448
453
 
449
 
again:
450
 
                pp = vm_page_lookup(obj, OFF_TO_IDX(start));
451
 
                if (pp != NULL && vm_page_sleep_if_busy(pp, FALSE,
452
 
                    "zfsmrb"))
453
 
                        goto again;
454
 
                if (pp == NULL) {
455
 
                        pp = vm_page_alloc(obj, OFF_TO_IDX(start),
456
 
                            VM_ALLOC_NOBUSY | VM_ALLOC_NORMAL);
457
 
                        if (pp == NULL) {
458
 
                                VM_OBJECT_UNLOCK(obj);
459
 
                                VM_WAIT;
460
 
                                VM_OBJECT_LOCK(obj);
461
 
                                goto again;
462
 
                        }
463
 
                }
 
454
                pp = vm_page_grab(obj, OFF_TO_IDX(start), VM_ALLOC_NOBUSY |
 
455
                    VM_ALLOC_NORMAL | VM_ALLOC_RETRY | VM_ALLOC_IGN_SBUSY);
464
456
                if (pp->valid == 0) {
465
457
                        vm_page_io_start(pp);
466
458
                        VM_OBJECT_UNLOCK(obj);
472
464
                        zfs_unmap_page(sf);
473
465
                        VM_OBJECT_LOCK(obj);
474
466
                        vm_page_io_finish(pp);
475
 
                        vm_page_lock_queues();
 
467
                        vm_page_lock(pp);
476
468
                        if (error) {
477
469
                                vm_page_free(pp);
478
470
                        } else {
479
471
                                pp->valid = VM_PAGE_BITS_ALL;
480
472
                                vm_page_activate(pp);
481
473
                        }
482
 
                        vm_page_unlock_queues();
 
474
                        vm_page_unlock(pp);
483
475
                }
484
476
                if (error)
485
477
                        break;
527
519
                if (pp = page_lookup(vp, start, off, bytes)) {
528
520
                        struct sf_buf *sf;
529
521
                        caddr_t va;
 
522
 
530
523
                        VM_OBJECT_UNLOCK(obj);
531
524
                        va = zfs_map_page(pp, &sf);
532
525
                        error = uiomove(va + off, bytes, UIO_READ, uio);
5561
5554
        KASSERT(vp->v_object == object, ("mismatching object"));
5562
5555
 
5563
5556
        VM_OBJECT_LOCK(object);
5564
 
        vm_page_lock_queues();
 
5557
 
5565
5558
        for (i = 0; i < pcount; i++) {
5566
5559
                if (i != reqpage) {
 
5560
                        vm_page_lock(m[i]);
5567
5561
                        vm_page_free(m[i]);
 
5562
                        vm_page_unlock(m[i]);
5568
5563
                }
5569
5564
        }
5570
 
        vm_page_unlock_queues();
5571
5565
 
5572
5566
        if (mreq->valid) {
5573
5567
                if (mreq->valid != VM_PAGE_BITS_ALL)
5712
5706
                struct thread *a_td;
5713
5707
        } */ *ap;
5714
5708
{
 
5709
        vnode_t *vp = ap->a_vp;
 
5710
        znode_t *zp = VTOZ(vp);
5715
5711
        accmode_t accmode;
5716
5712
        int error = 0;
5717
5713
 
5728
5724
        if (error == 0) {
5729
5725
                accmode = ap->a_accmode & ~(VREAD|VWRITE|VEXEC|VAPPEND);
5730
5726
                if (accmode != 0) {
5731
 
                        vnode_t *vp = ap->a_vp;
5732
 
                        znode_t *zp = VTOZ(vp);
5733
 
 
5734
5727
                        error = vaccess(vp->v_type, zp->z_mode, zp->z_uid,
5735
5728
                            zp->z_gid, accmode, ap->a_cred, NULL);
5736
5729
                }
5737
5730
        }
5738
5731
 
 
5732
        /*
 
5733
         * For VEXEC, ensure that at least one execute bit is set for
 
5734
         * non-directories.
 
5735
         */
 
5736
        if (error == 0 && (ap->a_accmode & VEXEC) != 0 && vp->v_type != VDIR &&
 
5737
            (zp->z_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) {
 
5738
                error = EACCES;
 
5739
        }
 
5740
 
5739
5741
        return (error);
5740
5742
}
5741
5743