/*
* Destroy the inode hash table.
*/
void
ufs_ihashuninit()
{
hashdestroy(ihashtbl, M_UFSIHASH, ihash);
mtx_destroy(&ufs_ihash_mtx);
}
/*
* Destroy inode hash table.
*/
void
ntfs_nthashdestroy(void)
{
hashdestroy(ntfs_nthashtbl, M_NTFSNTHASH, ntfs_nthash);
lockdestroy(&ntfs_hashlock);
mtx_destroy(&ntfs_nthash_mtx);
}
void drm_ht_remove(struct drm_open_hash *ht)
{
if (ht->table) {
hashdestroy(ht->table, DRM_MEM_HASHTAB, ht->mask);
ht->table = NULL;
}
}
int
fdesc_uninit(struct vfsconf *vfsp)
{
if (fdhashtbl)
hashdestroy(fdhashtbl, M_CACHE, fdhash);
return (0);
}
/*
* Stop per-filesystem syncer process
*/
void
vn_syncer_thr_stop(struct mount *mp)
{
struct syncer_ctx *ctx;
ctx = mp->mnt_syncer_ctx;
if (ctx == NULL)
return;
lwkt_gettoken(&ctx->sc_token);
/* Signal the syncer process to exit */
ctx->sc_flags |= SC_FLAG_EXIT;
wakeup(ctx);
/* Wait till syncer process exits */
while ((ctx->sc_flags & SC_FLAG_DONE) == 0)
tsleep(&ctx->sc_flags, 0, "syncexit", hz);
mp->mnt_syncer_ctx = NULL;
lwkt_reltoken(&ctx->sc_token);
hashdestroy(ctx->syncer_workitem_pending, M_DEVBUF, ctx->syncer_mask);
kfree(ctx, M_TEMP);
}
void
ip6_destroy()
{
hashdestroy(V_in6_ifaddrhashtbl, M_IFADDR, V_in6_ifaddrhmask);
nd6_destroy();
callout_drain(&V_in6_tmpaddrtimer_ch);
}
/*
* Uninit ready for unload.
*/
int
fdesc_uninit(struct vfsconf *vfsp)
{
hashdestroy(fdhashtbl, M_CACHE, fdhash);
mtx_destroy(&fdesc_hashmtx);
return (0);
}
void
ip6_destroy()
{
int i;
if ((i = pfil_head_unregister(&V_inet6_pfil_hook)) != 0)
printf("%s: WARNING: unable to unregister pfil hook, "
"error %d\n", __func__, i);
hashdestroy(V_in6_ifaddrhashtbl, M_IFADDR, V_in6_ifaddrhmask);
nd6_destroy();
callout_drain(&V_in6_tmpaddrtimer_ch);
}
/*
* Shut down the quota system.
*/
void
dquninit(void)
{
struct dquot *dq;
hashdestroy(dqhashtbl, M_DQUOT, dqhash);
while ((dq = TAILQ_FIRST(&dqfreelist)) != NULL) {
TAILQ_REMOVE(&dqfreelist, dq, dq_freelist);
mtx_destroy(&dq->dq_lock);
free(dq, M_DQUOT);
}
mtx_destroy(&dqhlock);
}
void
in_pcbgroup_destroy(struct inpcbinfo *pcbinfo)
{
struct inpcbgroup *pcbgroup;
u_int pgn;
if (pcbinfo->ipi_npcbgroups == 0)
return;
for (pgn = 0; pgn < pcbinfo->ipi_npcbgroups; pgn++) {
pcbgroup = &pcbinfo->ipi_pcbgroups[pgn];
KASSERT(LIST_EMPTY(pcbinfo->ipi_listhead),
("in_pcbinfo_destroy: listhead not empty"));
INP_GROUP_LOCK_DESTROY(pcbgroup);
hashdestroy(pcbgroup->ipg_hashbase, M_PCB,
pcbgroup->ipg_hashmask);
}
hashdestroy(pcbinfo->ipi_wildbase, M_PCB, pcbinfo->ipi_wildmask);
free(pcbinfo->ipi_pcbgroups, M_PCB);
pcbinfo->ipi_pcbgroups = NULL;
pcbinfo->ipi_npcbgroups = 0;
pcbinfo->ipi_hashfields = 0;
}
static void
ksem_module_destroy(void)
{
#ifdef COMPAT_FREEBSD32
syscall32_helper_unregister(ksem32_syscalls);
#endif
syscall_helper_unregister(ksem_syscalls);
hashdestroy(ksem_dictionary, M_KSEM, ksem_hash);
sx_destroy(&ksem_dict_lock);
mtx_destroy(&ksem_count_lock);
mtx_destroy(&sem_lock);
p31b_unsetcfg(CTL_P1003_1B_SEM_VALUE_MAX);
p31b_unsetcfg(CTL_P1003_1B_SEM_NSEMS_MAX);
}
void
drm_gem_names_fini(struct drm_gem_names *names)
{
struct drm_gem_name *np;
int i;
mtx_lock(&names->lock);
for (i = 0; i <= names->hash_mask; i++) {
while ((np = LIST_FIRST(&names->names_hash[i])) != NULL) {
drm_gem_names_delete_name(names, np);
mtx_lock(&names->lock);
}
}
mtx_unlock(&names->lock);
mtx_destroy(&names->lock);
hashdestroy(names->names_hash, M_GEM_NAMES, names->hash_mask);
delete_unrhdr(names->unr);
}
/* Unmount the filesystem described by mp. */
static int
smbfs_unmount(struct mount *mp, int mntflags)
{
struct smbmount *smp = VFSTOSMBFS(mp);
struct smb_cred scred;
int error, flags;
SMBVDEBUG("smbfs_unmount: flags=%04x\n", mntflags);
flags = 0;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
/*
* Keep trying to flush the vnode list for the mount while
* some are still busy and we are making progress towards
* making them not busy. This is needed because smbfs vnodes
* reference their parent directory but may appear after their
* parent in the list; one pass over the vnode list is not
* sufficient in this case.
*/
do {
smp->sm_didrele = 0;
/* There is 1 extra root vnode reference from smbfs_mount(). */
error = vflush(mp, 1, flags);
} while (error == EBUSY && smp->sm_didrele != 0);
if (error)
return error;
smb_makescred(&scred, curthread, smp->sm_cred);
error = smb_share_lock(smp->sm_share, LK_EXCLUSIVE);
if (error)
goto out;
smb_share_put(smp->sm_share, &scred);
mp->mnt_data = (qaddr_t)0;
if (smp->sm_cred)
crfree(smp->sm_cred);
if (smp->sm_hash)
hashdestroy(smp->sm_hash, M_SMBFSHASH, smp->sm_hashlen);
lockdestroy(&smp->sm_hashlock);
kfree(smp, M_SMBFSDATA);
mp->mnt_flag &= ~MNT_LOCAL;
out:
return error;
}
static void
free_tom_data(struct tom_data *td)
{
KASSERT(TAILQ_EMPTY(&td->toep_list),
("%s: toep_list not empty", __func__));
if (td->listen_mask != 0)
hashdestroy(td->listen_hash, M_CXGB, td->listen_mask);
if (mtx_initialized(&td->toep_list_lock))
mtx_destroy(&td->toep_list_lock);
if (mtx_initialized(&td->lctx_hash_lock))
mtx_destroy(&td->lctx_hash_lock);
if (mtx_initialized(&td->tid_release_lock))
mtx_destroy(&td->tid_release_lock);
if (td->l2t)
t3_free_l2t(td->l2t);
free_tid_tabs(&td->tid_maps);
free(td, M_CXGB);
}
void
fha_uninit(struct fha_params *softc)
{
sysctl_ctx_free(&softc->sysctl_ctx);
hashdestroy(softc->g_fha.hashtable, M_NFS_FHA, softc->g_fha.hashmask);
}
static int
smbfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
{
struct smbfs_args args; /* will hold data from mount request */
struct smbmount *smp = NULL;
struct smb_vc *vcp;
struct smb_share *ssp = NULL;
struct vnode *vp;
struct smb_cred scred;
int error;
int hsize;
char *pc, *pe;
if (data == NULL) {
kprintf("missing data argument\n");
return EINVAL;
}
if (mp->mnt_flag & MNT_UPDATE) {
kprintf("MNT_UPDATE not implemented");
return EOPNOTSUPP;
}
error = copyin(data, (caddr_t)&args, sizeof(struct smbfs_args));
if (error)
return error;
if (args.version != SMBFS_VERSION) {
kprintf("mount version mismatch: kernel=%d, mount=%d\n",
SMBFS_VERSION, args.version);
return EINVAL;
}
smb_makescred(&scred, curthread, cred);
error = smb_dev2share(args.dev, SMBM_EXEC, &scred, &ssp);
if (error) {
kprintf("invalid device handle %d (%d)\n", args.dev, error);
return error;
}
vcp = SSTOVC(ssp);
smb_share_unlock(ssp, 0);
mp->mnt_stat.f_iosize = SSTOVC(ssp)->vc_txmax;
smp = kmalloc(sizeof(*smp), M_SMBFSDATA, M_WAITOK | M_USE_RESERVE | M_ZERO);
mp->mnt_data = (qaddr_t)smp;
smp->sm_cred = crhold(cred);
hsize = vfs_inodehashsize();
smp->sm_hash = hashinit(hsize, M_SMBFSHASH, &smp->sm_hashlen);
if (smp->sm_hash == NULL)
goto bad;
lockinit(&smp->sm_hashlock, "smbfsh", 0, 0);
smp->sm_share = ssp;
smp->sm_root = NULL;
smp->sm_args = args;
smp->sm_caseopt = args.caseopt;
smp->sm_args.file_mode = (smp->sm_args.file_mode &
(S_IRWXU|S_IRWXG|S_IRWXO)) | S_IFREG;
smp->sm_args.dir_mode = (smp->sm_args.dir_mode &
(S_IRWXU|S_IRWXG|S_IRWXO)) | S_IFDIR;
/* simple_lock_init(&smp->sm_npslock);*/
pc = mp->mnt_stat.f_mntfromname;
pe = pc + sizeof(mp->mnt_stat.f_mntfromname);
bzero(pc, MNAMELEN);
*pc++ = '/';
*pc++ = '/';
pc=index(strncpy(pc, vcp->vc_username, pe - pc - 2), 0);
if (pc < pe-1) {
*(pc++) = '@';
pc = index(strncpy(pc, vcp->vc_srvname, pe - pc - 2), 0);
if (pc < pe - 1) {
*(pc++) = '/';
strncpy(pc, ssp->ss_name, pe - pc - 2);
}
}
/* protect against invalid mount points */
smp->sm_args.mount_point[sizeof(smp->sm_args.mount_point) - 1] = '\0';
vfs_getnewfsid(mp);
vfs_add_vnodeops(mp, &smbfs_vnode_vops, &mp->mnt_vn_norm_ops);
error = smbfs_root(mp, &vp);
if (error)
goto bad;
vn_unlock(vp);
SMBVDEBUG("root.v_refcnt = %08x\n", vp->v_refcnt);
#ifdef DIAGNOSTICS
SMBERROR("mp=%p\n", mp);
#endif
return error;
bad:
if (smp) {
if (smp->sm_cred)
crfree(smp->sm_cred);
if (smp->sm_hash)
hashdestroy(smp->sm_hash, M_SMBFSHASH,
smp->sm_hashlen);
lockdestroy(&smp->sm_hashlock);
kfree(smp, M_SMBFSDATA);
}
if (ssp)
smb_share_put(ssp, &scred);
return error;
}
/*
* Clean up the unionfs node.
*/
void
unionfs_noderem(struct vnode *vp, struct thread *td)
{
int count;
struct unionfs_node *unp, *unp_t1, *unp_t2;
struct unionfs_node_hashhead *hd;
struct unionfs_node_status *unsp, *unsp_tmp;
struct vnode *lvp;
struct vnode *uvp;
struct vnode *dvp;
/*
* Use the interlock to protect the clearing of v_data to
* prevent faults in unionfs_lock().
*/
VI_LOCK(vp);
unp = VTOUNIONFS(vp);
lvp = unp->un_lowervp;
uvp = unp->un_uppervp;
dvp = unp->un_dvp;
unp->un_lowervp = unp->un_uppervp = NULLVP;
vp->v_vnlock = &(vp->v_lock);
vp->v_data = NULL;
vp->v_object = NULL;
VI_UNLOCK(vp);
if (lvp != NULLVP)
VOP_UNLOCK(lvp, LK_RELEASE);
if (uvp != NULLVP)
VOP_UNLOCK(uvp, LK_RELEASE);
if (dvp != NULLVP && unp->un_hash.le_prev != NULL)
unionfs_rem_cached_vnode(unp, dvp);
if (lockmgr(vp->v_vnlock, LK_EXCLUSIVE, VI_MTX(vp)) != 0)
panic("the lock for deletion is unacquirable.");
if (lvp != NULLVP)
vrele(lvp);
if (uvp != NULLVP)
vrele(uvp);
if (dvp != NULLVP) {
vrele(dvp);
unp->un_dvp = NULLVP;
}
if (unp->un_path != NULL) {
free(unp->un_path, M_UNIONFSPATH);
unp->un_path = NULL;
}
if (unp->un_hashtbl != NULL) {
for (count = 0; count <= unp->un_hashmask; count++) {
hd = unp->un_hashtbl + count;
LIST_FOREACH_SAFE(unp_t1, hd, un_hash, unp_t2) {
LIST_REMOVE(unp_t1, un_hash);
unp_t1->un_hash.le_next = NULL;
unp_t1->un_hash.le_prev = NULL;
}
}
hashdestroy(unp->un_hashtbl, M_UNIONFSHASH, unp->un_hashmask);
}
/*
* Clean up the unionfs node.
*/
void
unionfs_noderem(struct vnode *vp, struct thread *td)
{
int vfslocked;
int count;
struct unionfs_node *unp, *unp_t1, *unp_t2;
struct unionfs_node_hashhead *hd;
struct unionfs_node_status *unsp, *unsp_tmp;
struct vnode *lvp;
struct vnode *uvp;
struct vnode *dvp;
/*
* Use the interlock to protect the clearing of v_data to
* prevent faults in unionfs_lock().
*/
VI_LOCK(vp);
unp = VTOUNIONFS(vp);
lvp = unp->un_lowervp;
uvp = unp->un_uppervp;
dvp = unp->un_dvp;
unp->un_lowervp = unp->un_uppervp = NULLVP;
vp->v_vnlock = &(vp->v_lock);
vp->v_data = NULL;
lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_INTERLOCK, VI_MTX(vp), td);
if (lvp != NULLVP)
VOP_UNLOCK(lvp, 0, td);
if (uvp != NULLVP)
VOP_UNLOCK(uvp, 0, td);
vp->v_object = NULL;
if (dvp != NULLVP && unp->un_hash.le_prev != NULL)
unionfs_rem_cached_vnode(unp, dvp);
if (lvp != NULLVP) {
vfslocked = VFS_LOCK_GIANT(lvp->v_mount);
vrele(lvp);
VFS_UNLOCK_GIANT(vfslocked);
}
if (uvp != NULLVP) {
vfslocked = VFS_LOCK_GIANT(uvp->v_mount);
vrele(uvp);
VFS_UNLOCK_GIANT(vfslocked);
}
if (dvp != NULLVP) {
vfslocked = VFS_LOCK_GIANT(dvp->v_mount);
vrele(dvp);
VFS_UNLOCK_GIANT(vfslocked);
unp->un_dvp = NULLVP;
}
if (unp->un_path != NULL) {
free(unp->un_path, M_UNIONFSPATH);
unp->un_path = NULL;
}
if (unp->un_hashtbl != NULL) {
for (count = 0; count <= unp->un_hashmask; count++) {
hd = unp->un_hashtbl + count;
LIST_FOREACH_SAFE(unp_t1, hd, un_hash, unp_t2) {
LIST_REMOVE(unp_t1, un_hash);
unp_t1->un_hash.le_next = NULL;
unp_t1->un_hash.le_prev = NULL;
}
}
hashdestroy(unp->un_hashtbl, M_UNIONFSHASH, unp->un_hashmask);
}
