kern/src/ns/pgrp.c - upstream - Git at Google

 /*
  * Copyright 2013 Google Inc.
  * Copyright (c) 1989-2003 by Lucent Technologies, Bell Laboratories.
  */
 #include <vfs.h>
 #include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <string.h>
 #include <stdio.h>
 #include <assert.h>
 #include <error.h>
 #include <cpio.h>
 #include <pmap.h>
 #include <smp.h>

 enum {
 	Whinesecs = 10,				/* frequency of out-of-resources printing */
 };

 static struct kref pgrpid[1] = { {(void *)1, fake_release} };

 static spinlock_t mountidlock[1];
 static struct kref mountid[1] = { {(void *)1, fake_release} };

 #if 0
 /* exception handling. We need to talk.*/
 void
 pgrpnote(uint32_t noteid, char *a, long n, int flag)
 {
 	Proc *p, *ep;
 	char buf[ERRMAX];

 	if (n >= ERRMAX - 1)
 		error(Etoobig);

 	memmove(buf, a, n);
 	buf[n] = 0;
 	p = proctab(0);
 	pp = p + conf.nproc;
 	for (; p < ep; p++) {
 		if (p->state == Dead)
 			continue;
 		if (up != p && p->noteid == noteid && p->kp == 0) {
 			qlock(&p->debug);
 			if (p->pid == 0 || p->noteid != noteid) {
 				qunlock(&p->debug);
 				continue;
 			}
 			if (!waserror()) {
 				postnote(p, 0, buf, flag);
 			}
 			poperror();
 			qunlock(&p->debug);
 		}
 	}
 }
 #endif

 struct pgrp *newpgrp(void)
 {
 	struct pgrp *p;

 	p = kzmalloc(sizeof(struct pgrp), KMALLOC_WAIT);
 	kref_init(&p->ref, fake_release, 1);
 	kref_get(pgrpid, 1);
 	p->pgrpid = kref_refcnt(pgrpid);
 	return p;
 }

 void closepgrp(struct pgrp *p)
 {
 	struct mhead **h, **e, *f, *next;

 	if (!kref_put(&p->ref))
 		return;

 	/* the p->debug stuff is not needed -- we think. */
 	//qlock(&p->debug);
 	wlock(&p->ns);
 	p->pgrpid = -1;

 	e = &p->mnthash[MNTHASH];
 	for (h = p->mnthash; h < e; h++) {
 		for (f = *h; f; f = next) {
 			wlock(&f->lock);
 			cclose(f->from);
 			mountfree(f->mount);
 			f->mount = NULL;
 			next = f->hash;
 			wunlock(&f->lock);
 			putmhead(f);
 		}
 	}
 	wunlock(&p->ns);
 	//qunlock(&p->debug);
 	kfree(p);
 }

 void pgrpinsert(struct mount **order, struct mount *m)
 {
 	struct mount *f;

 	m->order = 0;
 	if (*order == 0) {
 		*order = m;
 		return;
 	}
 	for (f = *order; f; f = f->order) {
 		if (m->mountid < f->mountid) {
 			m->order = f;
 			*order = m;
 			return;
 		}
 		order = &f->order;
 	}
 	*order = m;
 }

 /*
  * pgrpcpy MUST preserve the mountid allocation order of the parent group
  */
 void pgrpcpy(struct pgrp *to, struct pgrp *from)
 {
 	int i;
 	struct mount *n, *m, **link, *order;
 	struct mhead *f, **tom, **l, *mh;

 	wlock(&from->ns);
 	order = 0;
 	tom = to->mnthash;
 	for (i = 0; i < MNTHASH; i++) {
 		l = tom++;
 		for (f = from->mnthash[i]; f; f = f->hash) {
 			rlock(&f->lock);
 			mh = newmhead(f->from);
 			*l = mh;
 			l = &mh->hash;
 			link = &mh->mount;
 			for (m = f->mount; m; m = m->next) {
 				n = newmount(mh, m->to, m->mflag, m->spec);
 				m->copy = n;
 				pgrpinsert(&order, m);
 				*link = n;
 				link = &n->next;
 			}
 			runlock(&f->lock);
 		}
 	}
 	/*
 	 * Allocate mount ids in the same sequence as the parent group
 	 */
 	spin_lock(mountidlock);
 	/* this may not get the ids right. */
 	for (m = order; m; m = m->order)
 		m->copy->mountid = kref_refcnt(mountid);
 	kref_get(mountid, 1);
 	spin_unlock(mountidlock);
 	wunlock(&from->ns);
 }

 struct fgrp *dupfgrp(struct fgrp *f)
 {
 	struct fgrp *new;
 	struct chan *c;
 	int i;

 	new = kzmalloc(sizeof(struct fgrp), KMALLOC_WAIT);
 	if (f == NULL) {
 		new->fd = kzmalloc(DELTAFD * sizeof(struct chan *), KMALLOC_WAIT);
 		new->nfd = DELTAFD;
 		kref_init(&new->ref, fake_release, 1);
 		return new;
 	}

 	spin_lock(&f->lock);
 	if (f->closed) {
 		spin_unlock(&f->lock);
 		kfree(new);
 		error("File group closed");
 	}
 	/* Make new fd list shorter if possible, preserving quantization */
 	new->nfd = f->maxfd + 1;
 	i = new->nfd % DELTAFD;
 	if (i != 0)
 		new->nfd += DELTAFD - i;
 	new->fd = kzmalloc(new->nfd * sizeof(struct chan *), KMALLOC_WAIT);
 	if (new->fd == NULL) {
 		spin_unlock(&f->lock);
 		kfree(new);
 		error("no memory for fgrp");
 	}
 	kref_init(&new->ref, fake_release, 1);

 	new->maxfd = f->maxfd;
 	for (i = 0; i <= f->maxfd; i++) {
 		c = f->fd[i];
 		if (c) {
 			kref_get(&c->ref, 1);
 			new->fd[i] = c;
 		}
 	}
 	spin_unlock(&f->lock);

 	return new;
 }

 void closefgrp(struct fgrp *f)
 {
 	int i;
 	struct chan *c;

 	/* closefgrp can't be called from proc_destroy, due to races on the fgrp.
 	 * current->fgrp is a kref source, and we'd need some form of external sync
 	 * to remove it, since multiple kthreads could be accessing current->fgrp.
 	 * proc_free is synchronized, for instance.  we could put some sync in the
 	 * fgrp, but that would require splitting the deallocation (which we do
 	 * manually), and would require not having multiple procs per fgrp (which we
 	 * also require).  another option would be to use RCU: clear current->fgrp,
 	 * then closefgrp after a grace period. */
 	warn("Don't call closefgrp()");
 	if (f == 0)
 		return;

 	if (!kref_put(&f->ref))
 		return;

 	/*
 	 * If we get into trouble, forceclosefgrp
 	 * will bail us out.
 	 */
 	current->closingfgrp = f;
 	for (i = 0; i <= f->maxfd; i++) {
 		c = f->fd[i];
 		if (c) {
 			f->fd[i] = NULL;
 			cclose(c);
 		}
 	}
 	current->closingfgrp = NULL;

 	kfree(f->fd);
 	kfree(f);
 }

 /*
  * Called from sleep because up is in the middle
  * of closefgrp and just got a kill ctl message.
  * This usually means that up has wedged because
  * of some kind of deadly embrace with mntclose
  * trying to talk to itself.  To break free, hand the
  * unclosed channels to the close queue.  Once they
  * are finished, the blocked cclose that we've
  * interrupted will finish by itself.
  */
 void forceclosefgrp(void)
 {
 	int i;
 	struct chan *c;
 	struct fgrp *f;

 	if ( /* check that we're exiting somehow ...up->procctl != Proc_exitme || */
 		current->closingfgrp == NULL) {
 		printd("bad forceclosefgrp call");
 		return;
 	}

 	f = current->closingfgrp;
 	for (i = 0; i <= f->maxfd; i++) {
 		c = f->fd[i];
 		if (c) {
 			f->fd[i] = NULL;
 			printd("Not calling ccloseq ... fix me\n");
 			//ccloseq(c);
 		}
 	}
 }

 struct mount *newmount(struct mhead *mh, struct chan *to, int flag, char *spec)
 {
 	struct mount *m;

 	m = kzmalloc(sizeof(struct mount), KMALLOC_WAIT);
 	m->to = to;
 	m->head = mh;
 	kref_get(&to->ref, 1);
 	kref_get(mountid, 1);
 	m->mountid = kref_refcnt(mountid);
 	m->mflag = flag;
 	if (spec != 0)
 		kstrdup(&m->spec, spec);

 	return m;
 }

 void mountfree(struct mount *m)
 {
 	struct mount *f;

 	while (m) {
 		f = m->next;
 		cclose(m->to);
 		m->mountid = 0;
 		kfree(m->spec);
 		kfree(m);
 		m = f;
 	}
 }

 /* nah */
 #if 0
 void resrcwait(struct proc *up, char *reason)
 {
 	uint32_t now;
 	char *p;
 	static uint32_t lastwhine;

 	if (up == 0)
 		panic("resrcwait");

 	p = up->psstate;
 	if (reason) {
 		up->psstate = reason;
 		now = seconds();
 		/* don't tie up the console with complaints */
 		if (now - lastwhine > Whinesecs) {
 			lastwhine = now;
 			printd("%s\n", reason);
 		}
 	}

 	udelay_sched(300 * 1000);
 	up->psstate = p;
 }
 #endif
	/*
	* Copyright 2013 Google Inc.
	* Copyright (c) 1989-2003 by Lucent Technologies, Bell Laboratories.
	*/
	#include <vfs.h>
	#include <kfs.h>
	#include <slab.h>
	#include <kmalloc.h>
	#include <kref.h>
	#include <string.h>
	#include <stdio.h>
	#include <assert.h>
	#include <error.h>
	#include <cpio.h>
	#include <pmap.h>
	#include <smp.h>

	enum {
	Whinesecs = 10, /* frequency of out-of-resources printing */
	};

	static struct kref pgrpid[1] = { {(void *)1, fake_release} };

	static spinlock_t mountidlock[1];
	static struct kref mountid[1] = { {(void *)1, fake_release} };

	#if 0
	/* exception handling. We need to talk.*/
	void
	pgrpnote(uint32_t noteid, char *a, long n, int flag)
	{
	Proc p, ep;
	char buf[ERRMAX];

	if (n >= ERRMAX - 1)
	error(Etoobig);

	memmove(buf, a, n);
	buf[n] = 0;
	p = proctab(0);
	pp = p + conf.nproc;
	for (; p < ep; p++) {
	if (p->state == Dead)
	continue;
	if (up != p && p->noteid == noteid && p->kp == 0) {
	qlock(&p->debug);
	if (p->pid == 0 \|\| p->noteid != noteid) {
	qunlock(&p->debug);
	continue;
	}
	if (!waserror()) {
	postnote(p, 0, buf, flag);
	}
	poperror();
	qunlock(&p->debug);
	}
	}
	}
	#endif

	struct pgrp *newpgrp(void)
	{
	struct pgrp *p;

	p = kzmalloc(sizeof(struct pgrp), KMALLOC_WAIT);
	kref_init(&p->ref, fake_release, 1);
	kref_get(pgrpid, 1);
	p->pgrpid = kref_refcnt(pgrpid);
	return p;
	}

	void closepgrp(struct pgrp *p)
	{
	struct mhead h, e, f, next;

	if (!kref_put(&p->ref))
	return;

	/* the p->debug stuff is not needed -- we think. */
	//qlock(&p->debug);
	wlock(&p->ns);
	p->pgrpid = -1;

	e = &p->mnthash[MNTHASH];
	for (h = p->mnthash; h < e; h++) {
	for (f = *h; f; f = next) {
	wlock(&f->lock);
	cclose(f->from);
	mountfree(f->mount);
	f->mount = NULL;
	next = f->hash;
	wunlock(&f->lock);
	putmhead(f);
	}
	}
	wunlock(&p->ns);
	//qunlock(&p->debug);
	kfree(p);
	}

	void pgrpinsert(struct mount *order, struct mount m)
	{
	struct mount *f;

	m->order = 0;
	if (*order == 0) {
	*order = m;
	return;
	}
	for (f = *order; f; f = f->order) {
	if (m->mountid < f->mountid) {
	m->order = f;
	*order = m;
	return;
	}
	order = &f->order;
	}
	*order = m;
	}

	/*
	* pgrpcpy MUST preserve the mountid allocation order of the parent group
	*/
	void pgrpcpy(struct pgrp to, struct pgrp from)
	{
	int i;
	struct mount n, m, *link, order;
	struct mhead f, tom, l, mh;

	wlock(&from->ns);
	order = 0;
	tom = to->mnthash;
	for (i = 0; i < MNTHASH; i++) {
	l = tom++;
	for (f = from->mnthash[i]; f; f = f->hash) {
	rlock(&f->lock);
	mh = newmhead(f->from);
	*l = mh;
	l = &mh->hash;
	link = &mh->mount;
	for (m = f->mount; m; m = m->next) {
	n = newmount(mh, m->to, m->mflag, m->spec);
	m->copy = n;
	pgrpinsert(&order, m);
	*link = n;
	link = &n->next;
	}
	runlock(&f->lock);
	}
	}
	/*
	* Allocate mount ids in the same sequence as the parent group
	*/
	spin_lock(mountidlock);
	/* this may not get the ids right. */
	for (m = order; m; m = m->order)
	m->copy->mountid = kref_refcnt(mountid);
	kref_get(mountid, 1);
	spin_unlock(mountidlock);
	wunlock(&from->ns);
	}

	struct fgrp dupfgrp(struct fgrp f)
	{
	struct fgrp *new;
	struct chan *c;
	int i;

	new = kzmalloc(sizeof(struct fgrp), KMALLOC_WAIT);
	if (f == NULL) {
	new->fd = kzmalloc(DELTAFD * sizeof(struct chan *), KMALLOC_WAIT);
	new->nfd = DELTAFD;
	kref_init(&new->ref, fake_release, 1);
	return new;
	}

	spin_lock(&f->lock);
	if (f->closed) {
	spin_unlock(&f->lock);
	kfree(new);
	error("File group closed");
	}
	/* Make new fd list shorter if possible, preserving quantization */
	new->nfd = f->maxfd + 1;
	i = new->nfd % DELTAFD;
	if (i != 0)
	new->nfd += DELTAFD - i;
	new->fd = kzmalloc(new->nfd * sizeof(struct chan *), KMALLOC_WAIT);
	if (new->fd == NULL) {
	spin_unlock(&f->lock);
	kfree(new);
	error("no memory for fgrp");
	}
	kref_init(&new->ref, fake_release, 1);

	new->maxfd = f->maxfd;
	for (i = 0; i <= f->maxfd; i++) {
	c = f->fd[i];
	if (c) {
	kref_get(&c->ref, 1);
	new->fd[i] = c;
	}
	}
	spin_unlock(&f->lock);

	return new;
	}

	void closefgrp(struct fgrp *f)
	{
	int i;
	struct chan *c;

	/* closefgrp can't be called from proc_destroy, due to races on the fgrp.
	* current->fgrp is a kref source, and we'd need some form of external sync
	* to remove it, since multiple kthreads could be accessing current->fgrp.
	* proc_free is synchronized, for instance. we could put some sync in the
	* fgrp, but that would require splitting the deallocation (which we do
	* manually), and would require not having multiple procs per fgrp (which we
	* also require). another option would be to use RCU: clear current->fgrp,
	* then closefgrp after a grace period. */
	warn("Don't call closefgrp()");
	if (f == 0)
	return;

	if (!kref_put(&f->ref))
	return;

	/*
	* If we get into trouble, forceclosefgrp
	* will bail us out.
	*/
	current->closingfgrp = f;
	for (i = 0; i <= f->maxfd; i++) {
	c = f->fd[i];
	if (c) {
	f->fd[i] = NULL;
	cclose(c);
	}
	}
	current->closingfgrp = NULL;

	kfree(f->fd);
	kfree(f);
	}

	/*
	* Called from sleep because up is in the middle
	* of closefgrp and just got a kill ctl message.
	* This usually means that up has wedged because
	* of some kind of deadly embrace with mntclose
	* trying to talk to itself. To break free, hand the
	* unclosed channels to the close queue. Once they
	* are finished, the blocked cclose that we've
	* interrupted will finish by itself.
	*/
	void forceclosefgrp(void)
	{
	int i;
	struct chan *c;
	struct fgrp *f;

	if ( /* check that we're exiting somehow ...up->procctl != Proc_exitme \|\| */
	current->closingfgrp == NULL) {
	printd("bad forceclosefgrp call");
	return;
	}

	f = current->closingfgrp;
	for (i = 0; i <= f->maxfd; i++) {
	c = f->fd[i];
	if (c) {
	f->fd[i] = NULL;
	printd("Not calling ccloseq ... fix me\n");
	//ccloseq(c);
	}
	}
	}

	struct mount newmount(struct mhead mh, struct chan to, int flag, char spec)
	{
	struct mount *m;

	m = kzmalloc(sizeof(struct mount), KMALLOC_WAIT);
	m->to = to;
	m->head = mh;
	kref_get(&to->ref, 1);
	kref_get(mountid, 1);
	m->mountid = kref_refcnt(mountid);
	m->mflag = flag;
	if (spec != 0)
	kstrdup(&m->spec, spec);

	return m;
	}

	void mountfree(struct mount *m)
	{
	struct mount *f;

	while (m) {
	f = m->next;
	cclose(m->to);
	m->mountid = 0;
	kfree(m->spec);
	kfree(m);
	m = f;
	}
	}

	/* nah */
	#if 0
	void resrcwait(struct proc up, char reason)
	{
	uint32_t now;
	char *p;
	static uint32_t lastwhine;

	if (up == 0)
	panic("resrcwait");

	p = up->psstate;
	if (reason) {
	up->psstate = reason;
	now = seconds();
	/* don't tie up the console with complaints */
	if (now - lastwhine > Whinesecs) {
	lastwhine = now;
	printd("%s\n", reason);
	}
	}

	udelay_sched(300 * 1000);
	up->psstate = p;
	}
	#endif