Lines Matching defs:as
90 #include <vm/as.h>
161 static int ufs_map(struct vnode *, offset_t, struct as *, caddr_t *, size_t,
163 static int ufs_addmap(struct vnode *, offset_t, struct as *, caddr_t, size_t,
165 static int ufs_delmap(struct vnode *, offset_t, struct as *, caddr_t, size_t,
185 extern int as_map_locked(struct as *, caddr_t, size_t, int ((*)()), void *);
286 * Checking for VBAD here will also act as a forced umount check.
334 * In the case that a directory is opened for reading as a file
416 * Filter to determine if this request is suitable as a
419 * through FSYNC descriptors as the inode will be synchronously
671 * may also want to cache the pages for read as long as they are
680 * Freebehind exists so that as we read large files sequentially we
682 * longer to re-read from disk multiple small files as it does reading
768 * check for forced unmount - should not happen as
857 * have it as writer, i.e. if we are updating the quota inode.
858 * There is no potential deadlock scenario in this case as
992 * We have to drop the reader vfs_dqrwlock here as well.
1042 * partially or as a whole in uiomove.
1111 * allocated file blocks as well as pages. It's
1229 * If it was dropped, reacquire reader vfs_dqrwlock as well.
1452 * thread holding i_contents as writer to work properly
1745 * but the idea is to make this as seamless as poss.
1950 * the inode as that belonging to a compressed
1958 * This ioctl only marks the file as compressed - the
2091 * declare the inode as 'void *' argument.
2449 * mode bits expressed as "ufs specific" bits.
2787 * Check for a null component, which we should treat as
2789 * need a call to ufs_iaccess(), as it has already been
3291 * Make certain we don't attempt to look at a device node as
3468 * ufs_dircheckpath with the sdp and tdp locks held as RW_WRITER.
3471 * can be avoided by getting the locks as RW_READER here and then
3479 * is called). This is fine as long as ufs_lockfs_begin acts as a VOP
3567 * above the target, as this would orphan everything
3569 * write permission in the source so as to be able to
3618 * as RW_WRITER. To avoid that we have to hold the tdp and sdp locks
3619 * as RW_READERS till ufs_dircheckpath is done.
3626 * as to avoid deadlocking with someone else who is
3629 * good when we eventually get them back as writer.
3644 * as to avoid deadlocking with someone else who is
3647 * good when we eventually get them back as writer.
3681 * so as not to keep the filesystem from being
4153 * hold the quota lock as reader, and directory locks as writer.
4524 * again to use it as the offset for the read ahead.
4598 rwtype = RW_READER; /* start as a reader */
4602 * as writer somewhere above, then we don't need to grab the
4603 * lock as reader in this routine.
4611 * bmap_write() below (with i_contents as writer).
4619 * We may be getting called as a side effect of a bmap using
4683 * May be allocating disk blocks for holes here as
4690 * just as we do for MAXBMASK because uoff is a 64-bit
4692 * as we cannot change any ondisk data structures.
5037 * it more difficult on threads using directio as they
5313 * "io_off" and "io_len" are returned as
5607 struct as *as,
5648 as_rangelock(as);
5655 error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
5657 as_rangeunlock(as);
5669 while (!AS_LOCK_TRYENTER(as, RW_WRITER)) {
5675 * We can't hold as->a_lock and wait for lockfs to succeed because
5682 * as->a_lock and wait for ulp->ul_fs_lock status to change.
5685 AS_LOCK_EXIT(as);
5686 as_rangeunlock(as);
5720 error = as_map_locked(as, *addrp, len, segvn_create, &vn_a);
5723 as_rangeunlock(as);
5732 struct as *as,
5755 ufs_delmap(struct vnode *vp, offset_t off, struct as *as, caddr_t addr,
6546 * here as well.
6572 * as a reader. This is because ufs_rwunlock(), which will be
6617 * Check accessibility and write access of parent directory as we