linux 2.6.16.38 w/ vs2.0.3-rc1

[linux-2.6.git] / net / irda / irias_object.c

diff --git a/net/irda/irias_object.c b/net/irda/irias_object.c
index 058bf54..c6d169f 100644 (file)
--- a/net/irda/irias_object.c
+++ b/net/irda/irias_object.c
@@ -59,7 +59,7 @@ static char *strndup(char *str, int max)
        /* Allocate new string */
         new_str = kmalloc(len + 1, GFP_ATOMIC);
         if (new_str == NULL) {
-               WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
 
@@ -82,11 +82,10 @@ struct ias_object *irias_new_object( char *name, int id)
 
        IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
 
-       obj = (struct ias_object *) kmalloc(sizeof(struct ias_object),
-                                           GFP_ATOMIC);
+       obj = kmalloc(sizeof(struct ias_object), GFP_ATOMIC);
        if (obj == NULL) {
-               WARNING("%s(), Unable to allocate object!\n",
-                       __FUNCTION__);
+               IRDA_WARNING("%s(), Unable to allocate object!\n",
+                            __FUNCTION__);
                return NULL;
        }
        memset(obj, 0, sizeof( struct ias_object));
@@ -101,7 +100,8 @@ struct ias_object *irias_new_object( char *name, int id)
        obj->attribs = hashbin_new(HB_LOCK);
 
        if (obj->attribs == NULL) {
-               WARNING("%s(), Unable to allocate attribs!\n", __FUNCTION__);
+               IRDA_WARNING("%s(), Unable to allocate attribs!\n",
+                            __FUNCTION__);
                kfree(obj);
                return NULL;
        }
@@ -116,13 +116,12 @@ EXPORT_SYMBOL(irias_new_object);
  *    Delete given attribute and deallocate all its memory
  *
  */
-void __irias_delete_attrib(struct ias_attrib *attrib)
+static void __irias_delete_attrib(struct ias_attrib *attrib)
 {
-       ASSERT(attrib != NULL, return;);
-       ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
+       IRDA_ASSERT(attrib != NULL, return;);
+       IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
-       if (attrib->name)
-               kfree(attrib->name);
+       kfree(attrib->name);
 
        irias_delete_value(attrib->value);
        attrib->magic = ~IAS_ATTRIB_MAGIC;
@@ -132,11 +131,10 @@ void __irias_delete_attrib(struct ias_attrib *attrib)
 
 void __irias_delete_object(struct ias_object *obj)
 {
-       ASSERT(obj != NULL, return;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+       IRDA_ASSERT(obj != NULL, return;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
-       if (obj->name)
-               kfree(obj->name);
+       kfree(obj->name);
 
        hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);
 
@@ -156,14 +154,17 @@ int irias_delete_object(struct ias_object *obj)
 {
        struct ias_object *node;
 
-       ASSERT(obj != NULL, return -1;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
+       IRDA_ASSERT(obj != NULL, return -1;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
 
+       /* Remove from list */
        node = hashbin_remove_this(irias_objects, (irda_queue_t *) obj);
        if (!node)
-               return 0; /* Already removed */
+               IRDA_DEBUG( 0, "%s(), object already removed!\n",
+                           __FUNCTION__);
 
-       __irias_delete_object(node);
+       /* Destroy */
+       __irias_delete_object(obj);
 
        return 0;
 }
@@ -176,13 +177,14 @@ EXPORT_SYMBOL(irias_delete_object);
  *    the object, remove the object as well.
  *
  */
-int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib)
+int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib,
+                       int cleanobject)
 {
        struct ias_attrib *node;
 
-       ASSERT(obj != NULL, return -1;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
-       ASSERT(attrib != NULL, return -1;);
+       IRDA_ASSERT(obj != NULL, return -1;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
+       IRDA_ASSERT(attrib != NULL, return -1;);
 
        /* Remove attribute from object */
        node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
@@ -192,9 +194,13 @@ int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib)
        /* Deallocate attribute */
        __irias_delete_attrib(node);
 
-       /* Check if object has still some attributes */
+       /* Check if object has still some attributes, destroy it if none.
+        * At first glance, this look dangerous, as the kernel reference
+        * various IAS objects. However, we only use this function on
+        * user attributes, not kernel attributes, so there is no risk
+        * of deleting a kernel object this way. Jean II */
        node = (struct ias_attrib *) hashbin_get_first(obj->attribs);
-       if (!node)
+       if (cleanobject && !node)
                irias_delete_object(obj);
 
        return 0;
@@ -208,8 +214,8 @@ int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib)
  */
 void irias_insert_object(struct ias_object *obj)
 {
-       ASSERT(obj != NULL, return;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+       IRDA_ASSERT(obj != NULL, return;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
        hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
 }
@@ -223,7 +229,7 @@ EXPORT_SYMBOL(irias_insert_object);
  */
 struct ias_object *irias_find_object(char *name)
 {
-       ASSERT(name != NULL, return NULL;);
+       IRDA_ASSERT(name != NULL, return NULL;);
 
        /* Unsafe (locking), object might change */
        return hashbin_lock_find(irias_objects, 0, name);
@@ -240,9 +246,9 @@ struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
 {
        struct ias_attrib *attrib;
 
-       ASSERT(obj != NULL, return NULL;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
-       ASSERT(name != NULL, return NULL;);
+       IRDA_ASSERT(obj != NULL, return NULL;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
+       IRDA_ASSERT(name != NULL, return NULL;);
 
        attrib = hashbin_lock_find(obj->attribs, 0, name);
        if (attrib == NULL)
@@ -259,14 +265,14 @@ EXPORT_SYMBOL(irias_find_attrib);
  *    Add attribute to object
  *
  */
-void irias_add_attrib( struct ias_object *obj, struct ias_attrib *attrib,
-                      int owner)
+static void irias_add_attrib(struct ias_object *obj, struct ias_attrib *attrib,
+                            int owner)
 {
-       ASSERT(obj != NULL, return;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+       IRDA_ASSERT(obj != NULL, return;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
-       ASSERT(attrib != NULL, return;);
-       ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
+       IRDA_ASSERT(attrib != NULL, return;);
+       IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
 
        /* Set if attrib is owned by kernel or user space */
        attrib->value->owner = owner;
@@ -290,8 +296,8 @@ int irias_object_change_attribute(char *obj_name, char *attrib_name,
        /* Find object */
        obj = hashbin_lock_find(irias_objects, 0, obj_name);
        if (obj == NULL) {
-               WARNING("%s: Unable to find object: %s\n", __FUNCTION__,
-                       obj_name);
+               IRDA_WARNING("%s: Unable to find object: %s\n", __FUNCTION__,
+                            obj_name);
                return -1;
        }
 
@@ -301,8 +307,8 @@ int irias_object_change_attribute(char *obj_name, char *attrib_name,
        /* Find attribute */
        attrib = hashbin_find(obj->attribs, 0, attrib_name);
        if (attrib == NULL) {
-               WARNING("%s: Unable to find attribute: %s\n", __FUNCTION__,
-                       attrib_name);
+               IRDA_WARNING("%s: Unable to find attribute: %s\n",
+                            __FUNCTION__, attrib_name);
                spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
                return -1;
        }
@@ -337,14 +343,14 @@ void irias_add_integer_attrib(struct ias_object *obj, char *name, int value,
 {
        struct ias_attrib *attrib;
 
-       ASSERT(obj != NULL, return;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
-       ASSERT(name != NULL, return;);
+       IRDA_ASSERT(obj != NULL, return;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+       IRDA_ASSERT(name != NULL, return;);
 
-       attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
-                                              GFP_ATOMIC);
+       attrib = kmalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
        if (attrib == NULL) {
-               WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to allocate attribute!\n",
+                            __FUNCTION__);
                return;
        }
        memset(attrib, 0, sizeof( struct ias_attrib));
@@ -371,16 +377,16 @@ void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
 {
        struct ias_attrib *attrib;
 
-       ASSERT(obj != NULL, return;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+       IRDA_ASSERT(obj != NULL, return;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
-       ASSERT(name != NULL, return;);
-       ASSERT(octets != NULL, return;);
+       IRDA_ASSERT(name != NULL, return;);
+       IRDA_ASSERT(octets != NULL, return;);
 
-       attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
-                                              GFP_ATOMIC);
+       attrib = kmalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
        if (attrib == NULL) {
-               WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to allocate attribute!\n",
+                            __FUNCTION__);
                return;
        }
        memset(attrib, 0, sizeof( struct ias_attrib));
@@ -405,16 +411,16 @@ void irias_add_string_attrib(struct ias_object *obj, char *name, char *value,
 {
        struct ias_attrib *attrib;
 
-       ASSERT(obj != NULL, return;);
-       ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
+       IRDA_ASSERT(obj != NULL, return;);
+       IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
 
-       ASSERT(name != NULL, return;);
-       ASSERT(value != NULL, return;);
+       IRDA_ASSERT(name != NULL, return;);
+       IRDA_ASSERT(value != NULL, return;);
 
-       attrib = (struct ias_attrib *) kmalloc(sizeof( struct ias_attrib),
-                                              GFP_ATOMIC);
+       attrib = kmalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
        if (attrib == NULL) {
-               WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to allocate attribute!\n",
+                            __FUNCTION__);
                return;
        }
        memset(attrib, 0, sizeof( struct ias_attrib));
@@ -440,7 +446,7 @@ struct ias_value *irias_new_integer_value(int integer)
 
        value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
-               WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset(value, 0, sizeof(struct ias_value));
@@ -466,7 +472,7 @@ struct ias_value *irias_new_string_value(char *string)
 
        value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
-               WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset( value, 0, sizeof( struct ias_value));
@@ -493,7 +499,7 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
 
        value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
-               WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset(value, 0, sizeof(struct ias_value));
@@ -506,7 +512,7 @@ struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
 
        value->t.oct_seq = kmalloc(len, GFP_ATOMIC);
        if (value->t.oct_seq == NULL){
-               WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                kfree(value);
                return NULL;
        }
@@ -521,7 +527,7 @@ struct ias_value *irias_new_missing_value(void)
 
        value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
        if (value == NULL) {
-               WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
+               IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
        memset(value, 0, sizeof(struct ias_value));
@@ -542,7 +548,7 @@ void irias_delete_value(struct ias_value *value)
 {
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(value != NULL, return;);
+       IRDA_ASSERT(value != NULL, return;);
 
        switch (value->type) {
        case IAS_INTEGER: /* Fallthrough */
@@ -550,14 +556,12 @@ void irias_delete_value(struct ias_value *value)
                /* No need to deallocate */
                break;
        case IAS_STRING:
-               /* If string, deallocate string */
-               if (value->t.string != NULL)
-                       kfree(value->t.string);
+               /* Deallocate string */
+               kfree(value->t.string);
                break;
        case IAS_OCT_SEQ:
-               /* If byte stream, deallocate byte stream */
-                if (value->t.oct_seq != NULL)
-                        kfree(value->t.oct_seq);
+               /* Deallocate byte stream */
+                kfree(value->t.oct_seq);
                 break;
        default:
                IRDA_DEBUG(0, "%s(), Unknown value type!\n", __FUNCTION__);