1 files changed, 189 insertions, 0 deletions
diff --git a/net/tipc/ref.c b/net/tipc/ref.c
new file mode 100644
index 000000000000..944093fe246f
--- /dev/null
+++ b/net/tipc/ref.c
@@ -0,0 +1,189 @@
+/*
+ * net/tipc/ref.c: TIPC object registry code
+ * 
+ * Copyright (c) 1991-2006, Ericsson AB
+ * Copyright (c) 2004-2005, Wind River Systems
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "core.h"
+#include "ref.h"
+#include "port.h"
+#include "subscr.h"
+#include "name_distr.h"
+#include "name_table.h"
+#include "config.h"
+#include "discover.h"
+#include "bearer.h"
+#include "node.h"
+#include "bcast.h"
+/*
+ * Object reference table consists of 2**N entries.
+ *
+ * A used entry has object ptr != 0, reference == XXXX|own index
+ *                                   (XXXX changes each time entry is acquired) 
+ * A free entry has object ptr == 0, reference == YYYY|next free index
+ *                                   (YYYY is one more than last used XXXX)
+ *
+ * Free list is initially chained from entry (2**N)-1 to entry 1. 
+ * Entry 0 is not used to allow index 0 to indicate the end of the free list.
+ *
+ * Note: Any accidental reference of the form XXXX|0--0 won't match entry 0
+ * because entry 0's reference field has the form XXXX|1--1.
+ */
+struct ref_table ref_table = { 0 };
+rwlock_t reftbl_lock = RW_LOCK_UNLOCKED;
+/**
+ * ref_table_init - create reference table for objects
+ */
+int ref_table_init(u32 requested_size, u32 start)
+{
+        struct reference *table;
+        u32 sz = 1 << 4;
+        u32 index_mask;
+        int i;
+        while (sz < requested_size) {
+                sz <<= 1;
+        }
+        table = (struct reference *)vmalloc(sz * sizeof(struct reference));
+        if (table == NULL)
+                return -ENOMEM;
+        write_lock_bh(&reftbl_lock);
+        index_mask = sz - 1;
+        for (i = sz - 1; i >= 0; i--) {
+                table[i].object = 0;
+                table[i].lock = SPIN_LOCK_UNLOCKED;
+                table[i].data.next_plus_upper = (start & ~index_mask) + i - 1;
+        }
+        ref_table.entries = table;
+        ref_table.index_mask = index_mask;
+        ref_table.first_free = sz - 1;
+        ref_table.last_free = 1;
+        write_unlock_bh(&reftbl_lock);
+        return TIPC_OK;
+}
+/**
+ * ref_table_stop - destroy reference table for objects
+ */
+void ref_table_stop(void)
+{
+        if (!ref_table.entries)
+                return;
+        vfree(ref_table.entries);
+        ref_table.entries = 0;
+}
+/**
+ * ref_acquire - create reference to an object
+ * 
+ * Return a unique reference value which can be translated back to the pointer
+ * 'object' at a later time.  Also, pass back a pointer to the lock protecting 
+ * the object, but without locking it.
+ */
+u32 ref_acquire(void *object, spinlock_t **lock)
+{
+        struct reference *entry;
+        u32 index;
+        u32 index_mask;
+        u32 next_plus_upper;
+        u32 reference = 0;
+        assert(ref_table.entries && object);
+        write_lock_bh(&reftbl_lock);
+        if (ref_table.first_free) {
+                index = ref_table.first_free;
+                entry = &(ref_table.entries[index]);
+                index_mask = ref_table.index_mask;
+                /* take lock in case a previous user of entry still holds it */ 
+                spin_lock_bh(&entry->lock);  
+                next_plus_upper = entry->data.next_plus_upper;
+                ref_table.first_free = next_plus_upper & index_mask;
+                reference = (next_plus_upper & ~index_mask) + index;
+                entry->data.reference = reference;
+                entry->object = object;
+                if (lock != 0)
+                        *lock = &entry->lock;
+                spin_unlock_bh(&entry->lock);
+        }
+        write_unlock_bh(&reftbl_lock);
+        return reference;
+}
+/**
+ * ref_discard - invalidate references to an object
+ * 
+ * Disallow future references to an object and free up the entry for re-use.
+ * Note: The entry's spin_lock may still be busy after discard
+ */
+void ref_discard(u32 ref)
+{
+        struct reference *entry;
+        u32 index; 
+        u32 index_mask;
+        assert(ref_table.entries);
+        assert(ref != 0);
+        write_lock_bh(&reftbl_lock);
+        index_mask = ref_table.index_mask;
+        index = ref & index_mask;
+        entry = &(ref_table.entries[index]);
+        assert(entry->object != 0);
+        assert(entry->data.reference == ref);
+        /* mark entry as unused */
+        entry->object = 0;
+        if (ref_table.first_free == 0)
+                ref_table.first_free = index;
+        else
+                /* next_plus_upper is always XXXX|0--0 for last free entry */
+                ref_table.entries[ref_table.last_free].data.next_plus_upper 
+                        |= index;
+        ref_table.last_free = index;
+        /* increment upper bits of entry to invalidate subsequent references */
+        entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1);
+        write_unlock_bh(&reftbl_lock);
+}

diff --git a/net/tipc/ref.c b/net/tipc/ref.c new file mode 100644 index 000000000000..944093fe246f --- /dev/null +++ b/net/tipc/ref.c
@@ -0,0 +1,189 @@
	1	/*
	2	* net/tipc/ref.c: TIPC object registry code
	3	*
	4	* Copyright (c) 1991-2006, Ericsson AB
	5	* Copyright (c) 2004-2005, Wind River Systems
	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions are met:
	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. Neither the names of the copyright holders nor the names of its
	17	* contributors may be used to endorse or promote products derived from
	18	* this software without specific prior written permission.
	19	*
	20	* Alternatively, this software may be distributed under the terms of the
	21	* GNU General Public License ("GPL") version 2 as published by the Free
	22	* Software Foundation.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	* POSSIBILITY OF SUCH DAMAGE.
	35	*/
	36
	37	#include "core.h"
	38	#include "ref.h"
	39	#include "port.h"
	40	#include "subscr.h"
	41	#include "name_distr.h"
	42	#include "name_table.h"
	43	#include "config.h"
	44	#include "discover.h"
	45	#include "bearer.h"
	46	#include "node.h"
	47	#include "bcast.h"
	48
	49	/*
	50	* Object reference table consists of 2**N entries.
	51	*
	52	* A used entry has object ptr != 0, reference == XXXX\|own index
	53	* (XXXX changes each time entry is acquired)
	54	* A free entry has object ptr == 0, reference == YYYY\|next free index
	55	* (YYYY is one more than last used XXXX)
	56	*
	57	* Free list is initially chained from entry (2**N)-1 to entry 1.
	58	* Entry 0 is not used to allow index 0 to indicate the end of the free list.
	59	*
	60	* Note: Any accidental reference of the form XXXX\|0--0 won't match entry 0
	61	* because entry 0's reference field has the form XXXX\|1--1.
	62	*/
	63
	64	struct ref_table ref_table = { 0 };
	65
	66	rwlock_t reftbl_lock = RW_LOCK_UNLOCKED;
	67
	68	/**
	69	* ref_table_init - create reference table for objects
	70	*/
	71
	72	int ref_table_init(u32 requested_size, u32 start)
	73	{
	74	struct reference *table;
	75	u32 sz = 1 << 4;
	76	u32 index_mask;
	77	int i;
	78
	79	while (sz < requested_size) {
	80	sz <<= 1;
	81	}
	82	table = (struct reference )vmalloc(sz sizeof(struct reference));
	83	if (table == NULL)
	84	return -ENOMEM;
	85
	86	write_lock_bh(&reftbl_lock);
	87	index_mask = sz - 1;
	88	for (i = sz - 1; i >= 0; i--) {
	89	table[i].object = 0;
	90	table[i].lock = SPIN_LOCK_UNLOCKED;
	91	table[i].data.next_plus_upper = (start & ~index_mask) + i - 1;
	92	}
	93	ref_table.entries = table;
	94	ref_table.index_mask = index_mask;
	95	ref_table.first_free = sz - 1;
	96	ref_table.last_free = 1;
	97	write_unlock_bh(&reftbl_lock);
	98	return TIPC_OK;
	99	}
	100
	101	/**
	102	* ref_table_stop - destroy reference table for objects
	103	*/
	104
	105	void ref_table_stop(void)
	106	{
	107	if (!ref_table.entries)
	108	return;
	109
	110	vfree(ref_table.entries);
	111	ref_table.entries = 0;
	112	}
	113
	114	/**
	115	* ref_acquire - create reference to an object
	116	*
	117	* Return a unique reference value which can be translated back to the pointer
	118	* 'object' at a later time. Also, pass back a pointer to the lock protecting
	119	* the object, but without locking it.
	120	*/
	121
	122	u32 ref_acquire(void object, spinlock_t *lock)
	123	{
	124	struct reference *entry;
	125	u32 index;
	126	u32 index_mask;
	127	u32 next_plus_upper;
	128	u32 reference = 0;
	129
	130	assert(ref_table.entries && object);
	131
	132	write_lock_bh(&reftbl_lock);
	133	if (ref_table.first_free) {
	134	index = ref_table.first_free;
	135	entry = &(ref_table.entries[index]);
	136	index_mask = ref_table.index_mask;
	137	/* take lock in case a previous user of entry still holds it */
	138	spin_lock_bh(&entry->lock);
	139	next_plus_upper = entry->data.next_plus_upper;
	140	ref_table.first_free = next_plus_upper & index_mask;
	141	reference = (next_plus_upper & ~index_mask) + index;
	142	entry->data.reference = reference;
	143	entry->object = object;
	144	if (lock != 0)
	145	*lock = &entry->lock;
	146	spin_unlock_bh(&entry->lock);
	147	}
	148	write_unlock_bh(&reftbl_lock);
	149	return reference;
	150	}
	151
	152	/**
	153	* ref_discard - invalidate references to an object
	154	*
	155	* Disallow future references to an object and free up the entry for re-use.
	156	* Note: The entry's spin_lock may still be busy after discard
	157	*/
	158
	159	void ref_discard(u32 ref)
	160	{
	161	struct reference *entry;
	162	u32 index;
	163	u32 index_mask;
	164
	165	assert(ref_table.entries);
	166	assert(ref != 0);
	167
	168	write_lock_bh(&reftbl_lock);
	169	index_mask = ref_table.index_mask;
	170	index = ref & index_mask;
	171	entry = &(ref_table.entries[index]);
	172	assert(entry->object != 0);
	173	assert(entry->data.reference == ref);
	174
	175	/* mark entry as unused */
	176	entry->object = 0;
	177	if (ref_table.first_free == 0)
	178	ref_table.first_free = index;
	179	else
	180	/* next_plus_upper is always XXXX\|0--0 for last free entry */
	181	ref_table.entries[ref_table.last_free].data.next_plus_upper
	182	\|= index;
	183	ref_table.last_free = index;
	184
	185	/* increment upper bits of entry to invalidate subsequent references */
	186	entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1);
	187	write_unlock_bh(&reftbl_lock);
	188	}
	189