/* * POSIX device modes */ static int cd9660_rrip_device(ISO_RRIP_DEVICE *p, ISO_RRIP_ANALYZE *ana) { u_int high, low; high = isonum_733(p->dev_t_high); low = isonum_733(p->dev_t_low); if (high == 0) ana->inop->inode.iso_rdev = makeudev(umajor(low), uminor(low)); else ana->inop->inode.iso_rdev = makeudev(high, uminor(low)); ana->fields &= ~ISO_SUSP_DEVICE; return ISO_SUSP_DEVICE; }
int nfs_filestat(struct vnode *vp, struct filestat *fsp) { struct nfsnode nfsnode; mode_t mode; if (!kread(VTONFS(vp), &nfsnode, sizeof (nfsnode))) { dprintf(stderr, "can't read nfsnode at %p for pid %d\n", (void *)VTONFS(vp), Pid); return 0; } fsp->fsid = nfsnode.n_vattr.va_fsid; fsp->fileid = nfsnode.n_vattr.va_fileid; fsp->size = nfsnode.n_size; fsp->rdev = makeudev(nfsnode.n_vattr.va_rmajor, nfsnode.n_vattr.va_rminor); mode = (mode_t)nfsnode.n_vattr.va_mode; switch (vp->v_type) { case VREG: mode |= S_IFREG; break; case VDIR: mode |= S_IFDIR; break; case VBLK: mode |= S_IFBLK; break; case VCHR: mode |= S_IFCHR; break; case VLNK: mode |= S_IFLNK; break; case VSOCK: mode |= S_IFSOCK; break; case VFIFO: mode |= S_IFIFO; break; case VDATABASE: break; case VINT: case VNON: case VBAD: return 0; } fsp->mode = mode; return 1; }
/* Add this target pdev dependiences to prop_array_t */ static int dm_target_linear_deps(dm_table_entry_t * table_en, prop_array_t prop_array) { dm_target_linear_config_t *tlc; struct vattr va; int error; if (table_en->target_config == NULL) return ENOENT; tlc = table_en->target_config; if ((error = VOP_GETATTR(tlc->pdev->pdev_vnode, &va)) != 0) return error; prop_array_add_uint64(prop_array, (uint64_t) makeudev(va.va_rmajor, va.va_rminor)); return 0; }
/* * Generate properties from stripe table entry. */ static int dm_target_stripe_deps(dm_table_entry_t *table_en, prop_array_t prop_array) { dm_target_stripe_config_t *tsc; struct vattr va; int error; int n; if (table_en->target_config == NULL) return ENOENT; tsc = table_en->target_config; error = 0; for (n = 0; n < tsc->stripe_num; ++n) { error = VOP_GETATTR(tsc->stripe_devs[n].pdev->pdev_vnode, &va); if (error) break; prop_array_add_uint64(prop_array, (uint64_t)makeudev(va.va_rmajor, va.va_rminor)); } return (error); }
void nfs4_vnop_loadattrcache(struct vnode *vp, struct nfsv4_fattr *fap, struct vattr *vaper) { struct vattr *vap; struct nfsnode *np; int32_t rdev; enum vtype vtyp; u_short vmode; struct timespec mtime; struct timeval tv; microtime(&tv); vtyp = nv3tov_type[fap->fa4_type & 0x7]; vmode = (fap->fa4_valid & FA4V_MODE) ? fap->fa4_mode : 0777; rdev = (fap->fa4_valid & FA4V_RDEV) ? makeudev(fap->fa4_rdev_major, fap->fa4_rdev_minor) : 0; if (fap->fa4_valid & FA4V_MTIME) mtime = fap->fa4_mtime; else bzero(&mtime, sizeof mtime); /* * If v_type == VNON it is a new node, so fill in the v_type, * n_mtime fields. Check to see if it represents a special * device, and if so, check for a possible alias. Once the * correct vnode has been obtained, fill in the rest of the * information. */ np = VTONFS(vp); vap = &np->n_vattr; if (vp->v_type != vtyp || np->n_mtime == 0) { bzero(vap, sizeof *vap); vp->v_type = vtyp; np->n_mtime = mtime.tv_sec; } vap->va_type = vtyp; vap->va_mode = (vmode & 07777); vap->va_rdev = rdev; vap->va_mtime = mtime; vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; if (fap->fa4_valid & FA4V_NLINK) vap->va_nlink = fap->fa4_nlink; if (fap->fa4_valid & FA4V_UID) vap->va_uid = fap->fa4_uid; if (fap->fa4_valid & FA4V_GID) vap->va_gid = fap->fa4_gid; vap->va_size = fap->fa4_size; vap->va_blocksize = NFS_FABLKSIZE; vap->va_bytes = fap->fa4_size; if (fap->fa4_valid & FA4V_FILEID) vap->va_fileid = nfs_v4fileid4_to_fileid(fap->fa4_fileid); if (fap->fa4_valid & FA4V_ATIME) vap->va_atime = fap->fa4_atime; if (fap->fa4_valid & FA4V_CTIME) vap->va_ctime = fap->fa4_ctime; vap->va_flags = 0; vap->va_filerev = 0; /* XXX dontshrink flag? */ if (vap->va_size != np->n_size) { if (vap->va_type == VREG) { if (np->n_flag & NMODIFIED) { if (vap->va_size < np->n_size) vap->va_size = np->n_size; else np->n_size = vap->va_size; } else np->n_size = vap->va_size; vnode_pager_setsize(vp, np->n_size); } else np->n_size = vap->va_size; } np->n_attrstamp = tv.tv_sec; if (vaper != NULL) { bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap)); if (np->n_flag & NCHG) { if (np->n_flag & NACC) vaper->va_atime = np->n_atim; if (np->n_flag & NUPD) vaper->va_mtime = np->n_mtim; } } }
/* * Allocates a new node of type 'type' inside the 'tmp' mount point, with * its owner set to 'uid', its group to 'gid' and its mode set to 'mode', * using the credentials of the process 'p'. * * If the node type is set to 'VDIR', then the parent parameter must point * to the parent directory of the node being created. It may only be NULL * while allocating the root node. * * If the node type is set to 'VBLK' or 'VCHR', then the rdev parameter * specifies the device the node represents. * * If the node type is set to 'VLNK', then the parameter target specifies * the file name of the target file for the symbolic link that is being * created. * * Note that new nodes are retrieved from the available list if it has * items or, if it is empty, from the node pool as long as there is enough * space to create them. * * Returns zero on success or an appropriate error code on failure. */ int tmpfs_alloc_node(struct tmpfs_mount *tmp, enum vtype type, uid_t uid, gid_t gid, mode_t mode, char *target, int rmajor, int rminor, struct tmpfs_node **node) { struct tmpfs_node *nnode; struct timespec ts; udev_t rdev; KKASSERT(IFF(type == VLNK, target != NULL)); KKASSERT(IFF(type == VBLK || type == VCHR, rmajor != VNOVAL)); if (tmp->tm_nodes_inuse >= tmp->tm_nodes_max) return (ENOSPC); nnode = objcache_get(tmp->tm_node_pool, M_WAITOK | M_NULLOK); if (nnode == NULL) return (ENOSPC); /* Generic initialization. */ nnode->tn_type = type; vfs_timestamp(&ts); nnode->tn_ctime = nnode->tn_mtime = nnode->tn_atime = ts.tv_sec; nnode->tn_ctimensec = nnode->tn_mtimensec = nnode->tn_atimensec = ts.tv_nsec; nnode->tn_uid = uid; nnode->tn_gid = gid; nnode->tn_mode = mode; nnode->tn_id = tmpfs_fetch_ino(tmp); nnode->tn_advlock.init_done = 0; KKASSERT(nnode->tn_links == 0); /* Type-specific initialization. */ switch (nnode->tn_type) { case VBLK: case VCHR: rdev = makeudev(rmajor, rminor); if (rdev == NOUDEV) { objcache_put(tmp->tm_node_pool, nnode); return(EINVAL); } nnode->tn_rdev = rdev; break; case VDIR: RB_INIT(&nnode->tn_dir.tn_dirtree); RB_INIT(&nnode->tn_dir.tn_cookietree); nnode->tn_size = 0; break; case VFIFO: /* FALLTHROUGH */ case VSOCK: break; case VLNK: nnode->tn_size = strlen(target); nnode->tn_link = kmalloc(nnode->tn_size + 1, tmp->tm_name_zone, M_WAITOK | M_NULLOK); if (nnode->tn_link == NULL) { objcache_put(tmp->tm_node_pool, nnode); return (ENOSPC); } bcopy(target, nnode->tn_link, nnode->tn_size); nnode->tn_link[nnode->tn_size] = '\0'; break; case VREG: nnode->tn_reg.tn_aobj = swap_pager_alloc(NULL, 0, VM_PROT_DEFAULT, 0); nnode->tn_reg.tn_aobj_pages = 0; nnode->tn_size = 0; vm_object_set_flag(nnode->tn_reg.tn_aobj, OBJ_NOPAGEIN); break; default: panic("tmpfs_alloc_node: type %p %d", nnode, (int)nnode->tn_type); } TMPFS_NODE_LOCK(nnode); TMPFS_LOCK(tmp); LIST_INSERT_HEAD(&tmp->tm_nodes_used, nnode, tn_entries); tmp->tm_nodes_inuse++; TMPFS_UNLOCK(tmp); TMPFS_NODE_UNLOCK(nnode); *node = nnode; return 0; }