WebSVN – Kolibri OS – Diff – /drivers/ddk/linux/idr.c

+	}
 //   spin_unlock_irqrestore(&idp->lock, flags);
 	return(p);
+}
 static void idr_layer_rcu_free(struct rcu_head *head)
+{
 	struct idr_layer *layer;
     layer = container_of(head, struct idr_layer, rcu_head);
-    kfree(layer);
-}
     kfree(layer);
+}
 static inline void free_layer(struct idr_layer *p)
-{
     kfree(p);
     kfree(p);
+}
 /* only called when idp->lock is held */
 		id = id >> IDR_BITS;
 		__set_bit((id & IDR_MASK), &p->bitmap);
+	}
+}
 /**
- * idr_pre_get - reserver resources for idr allocation
+ * idr_pre_get - reserve resources for idr allocation
  * @idp:	idr handle
  * @gfp_mask:	memory allocation flags
  *
- * This function should be called prior to locking and calling the
+ * This function should be called prior to calling the idr_get_new* functions.
+ * It preallocates enough memory to satisfy the worst possible allocation. The
- * idr_get_new* functions. It preallocates enough memory to satisfy
+ * caller should pass in GFP_KERNEL if possible.  This of course requires that
- * the worst possible allocation.
+ * no spinning locks be held.
  *
- * If the system is REALLY out of memory this function returns 0,
+ * If the system is REALLY out of memory this function returns %0,
- * otherwise 1.
+ * otherwise %1.
  */
-int idr_pre_get(struct idr *idp, u32_t gfp_mask)
+int idr_pre_get(struct idr *idp, gfp_t gfp_mask)
+{
    while (idp->id_free_cnt < IDR_FREE_MAX) {
        struct idr_layer *new;
        new = kzalloc(sizeof(struct idr_layer), gfp_mask);
 	pa[l] = p;
 	return id;
-}
+}
 static int idr_get_empty_slot(struct idr *idp, int starting_id,
 			      struct idr_layer **pa)
+{
+}
 /**
  * idr_get_new_above - allocate new idr entry above or equal to a start id
  * @idp: idr handle
- * @ptr: pointer you want associated with the ide
+ * @ptr: pointer you want associated with the id
- * @start_id: id to start search at
+ * @starting_id: id to start search at
  * @id: pointer to the allocated handle
+ *
  * This is the allocate id function.  It should be called with any
  * required locks.
  *
- * If memory is required, it will return -EAGAIN, you should unlock
+ * If allocation from IDR's private freelist fails, idr_get_new_above() will
- * and go back to the idr_pre_get() call.  If the idr is full, it will
+ * return %-EAGAIN.  The caller should retry the idr_pre_get() call to refill
- * return -ENOSPC.
+ * IDR's preallocation and then retry the idr_get_new_above() call.
+ *
+ * If the idr is full idr_get_new_above() will return %-ENOSPC.
  *
- * @id returns a value in the range @starting_id ... 0x7fffffff
+ * @id returns a value in the range @starting_id ... %0x7fffffff
  */
 int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id)
+{
+	int rv;
 	int rv;
     rv = idr_get_new_above_int(idp, ptr, starting_id);
 	/*
 	 * This is a cheap hack until the IDR code can be fixed to
 	 * return proper error values.
+}
 /**
  * idr_get_new - allocate new idr entry
  * @idp: idr handle
- * @ptr: pointer you want associated with the ide
+ * @ptr: pointer you want associated with the id
  * @id: pointer to the allocated handle
+ *
- *
+ * If allocation from IDR's private freelist fails, idr_get_new_above() will
- * This is the allocate id function.  It should be called with any
+ * return %-EAGAIN.  The caller should retry the idr_pre_get() call to refill
- * required locks.
+ * IDR's preallocation and then retry the idr_get_new_above() call.
  *
- * If memory is required, it will return -EAGAIN, you should unlock
- * and go back to the idr_pre_get() call.  If the idr is full, it will
- * return -ENOSPC.
+ * If the idr is full idr_get_new_above() will return %-ENOSPC.
  *
- * @id returns a value in the range 0 ... 0x7fffffff
+ * @id returns a value in the range %0 ... %0x7fffffff
  */
 int idr_get_new(struct idr *idp, void *ptr, int *id)
+{
 	} else
 		idr_remove_warning(id);
+}
 /**
- * idr_remove - remove the given id and free it's slot
+ * idr_remove - remove the given id and free its slot
  * @idp: idr handle
  * @id: unique key
  */
 void idr_remove(struct idr *idp, int id)
+ *
  * idr_destroy() only frees up unused, cached idp_layers, but this
  * function will remove all id mappings and leave all idp_layers
  * unused.
+ *
- * A typical clean-up sequence for objects stored in an idr tree, will
+ * A typical clean-up sequence for objects stored in an idr tree will
  * use idr_for_each() to free all objects, if necessay, then
  * idr_remove_all() to remove all ids, and idr_destroy() to free
  * up the cached idr_layers.
  */
 void idr_remove_all(struct idr *idp)
+{
 	int n, id, max;
+	int bt_mask;
 	struct idr_layer *p;
 	struct idr_layer *pa[MAX_LEVEL];
 	struct idr_layer **paa = &pa[0];
 			n -= IDR_BITS;
 			*paa++ = p;
 			p = p->ary[(id >> n) & IDR_MASK];
+		}
 		bt_mask = id;
+		id += 1 << n;
-		id += 1 << n;
+		/* Get the highest bit that the above add changed from 0->1. */
-		while (n < fls(id)) {
+		while (n < fls(id ^ bt_mask)) {
 			if (p)
 				free_layer(p);
 			n += IDR_BITS;
 			p = *--paa;
 	idp->layers = 0;
+}
 /**
  * idr_destroy - release all cached layers within an idr tree
- * idp: idr handle
+ * @idp: idr handle
  */
 void idr_destroy(struct idr *idp)
+{
 	while (idp->id_free_cnt) {
  * to this function.  It is not safe to modify the idr tree while in
  * the callback, so functions such as idr_get_new and idr_remove are
  * not allowed.
+ *
  * We check the return of @fn each time. If it returns anything other
- * than 0, we break out and return that value.
+ * than %0, we break out and return that value.
+ *
  * The caller must serialize idr_for_each() vs idr_get_new() and idr_remove().
  */
 int idr_for_each(struct idr *idp,
 		 int (*fn)(int id, void *p, void *data), void *data)
 EXPORT_SYMBOL(idr_for_each);
 /**
  * idr_get_next - lookup next object of id to given id.
  * @idp: idr handle
- * @id:  pointer to lookup key
+ * @nextidp:  pointer to lookup key
+ *
+ * Returns pointer to registered object with id, which is next number to
- * Returns pointer to registered object with id, which is next number to
+ * given id. After being looked up, *@nextidp will be updated for the next
- * given id.
+ * iteration.
  */
 void *idr_get_next(struct idr *idp, int *nextidp)
  * @idp: idr handle
  * @ptr: pointer you want associated with the id
  * @id: lookup key
+ *
  * Replace the pointer registered with an id and return the old value.
- * A -ENOENT return indicates that @id was not found.
+ * A %-ENOENT return indicates that @id was not found.
- * A -EINVAL return indicates that @id was not within valid constraints.
+ * A %-EINVAL return indicates that @id was not within valid constraints.
+ *
  * The caller must serialize with writers.
  */
 void *idr_replace(struct idr *idp, void *ptr, int id)
+{
 #if 0
 /*
  * IDA - IDR based ID allocator
  *
- * this is id allocator without id -> pointer translation.  Memory
+ * This is id allocator without id -> pointer translation.  Memory
  * usage is much lower than full blown idr because each id only
  * occupies a bit.  ida uses a custom leaf node which contains
  * IDA_BITMAP_BITS slots.
+ *
+ *
  * This function should be called prior to locking and calling the
  * following function.  It preallocates enough memory to satisfy the
  * worst possible allocation.
+ *
- * If the system is REALLY out of memory this function returns 0,
+ * If the system is REALLY out of memory this function returns %0,
- * otherwise 1.
+ * otherwise %1.
  */
 int ida_pre_get(struct ida *ida, gfp_t gfp_mask)
+{
 	/* allocate idr_layers */
 	if (!idr_pre_get(&ida->idr, gfp_mask))
 EXPORT_SYMBOL(ida_pre_get);
 /**
  * ida_get_new_above - allocate new ID above or equal to a start id
  * @ida:	ida handle
- * @staring_id:	id to start search at
+ * @starting_id: id to start search at
  * @p_id:	pointer to the allocated handle
  *
- * Allocate new ID above or equal to @ida.  It should be called with
+ * Allocate new ID above or equal to @starting_id.  It should be called
- * any required locks.
+ * with any required locks.
  *
- * If memory is required, it will return -EAGAIN, you should unlock
+ * If memory is required, it will return %-EAGAIN, you should unlock
  * and go back to the ida_pre_get() call.  If the ida is full, it will
- * return -ENOSPC.
+ * return %-ENOSPC.
  *
- * @p_id returns a value in the range @starting_id ... 0x7fffffff.
+ * @p_id returns a value in the range @starting_id ... %0x7fffffff.
  */
 int ida_get_new_above(struct ida *ida, int starting_id, int *p_id)
+{
 	struct idr_layer *pa[MAX_LEVEL];
  * @ida:	idr handle
  * @p_id:	pointer to the allocated handle
+ *
  * Allocate new ID.  It should be called with any required locks.
+ *
- * If memory is required, it will return -EAGAIN, you should unlock
+ * If memory is required, it will return %-EAGAIN, you should unlock
  * and go back to the idr_pre_get() call.  If the idr is full, it will
- * return -ENOSPC.
+ * return %-ENOSPC.
+ *
- * @id returns a value in the range 0 ... 0x7fffffff.
+ * @p_id returns a value in the range %0 ... %0x7fffffff.
  */
 int ida_get_new(struct ida *ida, int *p_id)
+{
 	return ida_get_new_above(ida, 0, p_id);
+}
+}
 EXPORT_SYMBOL(ida_remove);
 /**
  * ida_destroy - release all cached layers within an ida tree
- * ida:		ida handle
+ * @ida:		ida handle
  */
 void ida_destroy(struct ida *ida)
+{
 	idr_destroy(&ida->idr);

Subversion Repositories Kolibri OS

(root)/drivers/ddk/linux/idr.c – Rev 1412 → 2966