- cleanups in comments, struct mtrack renamed to struct mem_track.

- making lvfs_memdbg_show() show possible memory leaks warning even if
  memory allocation tracking is not enabled.

diff --git a/lustre/include/linux/obd_support.h b/lustre/include/linux/obd_support.h
index 6464e55..fe95a50 100644 (file)
--- a/lustre/include/linux/obd_support.h
+++ b/lustre/include/linux/obd_support.h
@@ -313,25 +313,25 @@ extern atomic_t portal_kmemory;
 #if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__)
 #define MEM_LOC_LEN 128
 
-struct mtrack {
+struct mem_track {
         struct hlist_node m_hash;
         char m_loc[MEM_LOC_LEN];
         void *m_ptr;
         int m_size;
 };
 
-void lvfs_memdbg_insert(struct mtrack *mt);
-void lvfs_memdbg_remove(struct mtrack *mt);
-struct mtrack *lvfs_memdbg_find(void *ptr);
+void lvfs_memdbg_insert(struct mem_track *mt);
+void lvfs_memdbg_remove(struct mem_track *mt);
+struct mem_track *lvfs_memdbg_find(void *ptr);
 
-int lvfs_memdbg_check_insert(struct mtrack *mt);
-struct mtrack *lvfs_memdbg_check_remove(void *ptr);
+int lvfs_memdbg_check_insert(struct mem_track *mt);
+struct mem_track *lvfs_memdbg_check_remove(void *ptr);
 
-static inline struct mtrack *
-__new_mtrack(void *ptr, int size,
-             char *file, int line)
+static inline struct mem_track *
+__new_mem_track(void *ptr, int size,
+                char *file, int line)
 {
-        struct mtrack *mt;
+        struct mem_track *mt;
 
         mt = kmalloc(sizeof(*mt), GFP_KERNEL);
         if (!mt)
@@ -346,34 +346,34 @@ __new_mtrack(void *ptr, int size,
 }
 
 static inline void
-__free_mtrack(struct mtrack *mt)
+__free_mem_track(struct mem_track *mt)
 {
         kfree(mt);
 }
 
 static inline int
-__get_mtrack(void *ptr, int size,
-             char *file, int line)
+__get_mem_track(void *ptr, int size,
+                char *file, int line)
 {
-        struct mtrack *mt;
+        struct mem_track *mt;
 
-        mt = __new_mtrack(ptr, size, file, line);
+        mt = __new_mem_track(ptr, size, file, line);
         if (!mt) {
                 CWARN("can't allocate new memory track\n");
                 return 0;
         }
         
         if (!lvfs_memdbg_check_insert(mt))
-                __free_mtrack(mt);
+                __free_mem_track(mt);
         
         return 1;
 }
 
 static inline int
-__put_mtrack(void *ptr, int size,
-             char *file, int line)
+__put_mem_track(void *ptr, int size,
+                char *file, int line)
 {
-        struct mtrack *mt;
+        struct mem_track *mt;
 
         if (!(mt = lvfs_memdbg_check_remove(ptr))) {
                 CWARN("ptr 0x%p is not allocated. Attempt to free "
@@ -386,23 +386,23 @@ __put_mtrack(void *ptr, int size,
                               "than allocated (%d != %d) at %s:%d\n",
                               mt->m_size, size, file, line);
                 }
-                __free_mtrack(mt);
+                __free_mem_track(mt);
                 return 1;
         }
 }
 
-#define get_mtrack(ptr, size, file, line)                                            \
-        __get_mtrack((ptr), (size), (file), (line))
+#define get_mem_track(ptr, size, file, line)                                         \
+        __get_mem_track((ptr), (size), (file), (line))
 
-#define put_mtrack(ptr, size, file, line)                                            \
-        __put_mtrack((ptr), (size), (file), (line))
+#define put_mem_track(ptr, size, file, line)                                         \
+        __put_mem_track((ptr), (size), (file), (line))
 
 #else /* !CONFIG_DEBUG_MEMORY */
 
-#define get_mtrack(ptr, size, file, line)                                            \
+#define get_mem_track(ptr, size, file, line)                                         \
         do {} while (0)
 
-#define put_mtrack(ptr, size, file, line)                                            \
+#define put_mem_track(ptr, size, file, line)                                         \
         do {} while (0)
 #endif /* !CONFIG_DEBUG_MEMORY */
 
@@ -419,7 +419,7 @@ do {
                 atomic_add(size, &obd_memory);                                       \
                 if (atomic_read(&obd_memory) > obd_memmax)                           \
                         obd_memmax = atomic_read(&obd_memory);                       \
-                get_mtrack((ptr), (size), __FILE__, __LINE__);                       \
+                get_mem_track((ptr), (size), __FILE__, __LINE__);                    \
                 CDEBUG(D_MALLOC, "kmalloced '" #ptr "': %d at %p (tot %d)\n",        \
                        (int)(size), (ptr), atomic_read(&obd_memory));                \
         }                                                                            \
@@ -448,7 +448,7 @@ do {
                 atomic_add(size, &obd_memory);                                       \
                 if (atomic_read(&obd_memory) > obd_memmax)                           \
                         obd_memmax = atomic_read(&obd_memory);                       \
-                get_mtrack((ptr), (size), __FILE__, __LINE__);                       \
+                get_mem_track((ptr), (size), __FILE__, __LINE__);                    \
                 CDEBUG(D_MALLOC, "vmalloced '" #ptr "': %d at %p (tot %d)\n",        \
                        (int)(size), ptr, atomic_read(&obd_memory));                  \
         }                                                                            \
@@ -471,7 +471,7 @@ do {
 #define OBD_FREE(ptr, size)                                                          \
 do {                                                                                 \
         LASSERT(ptr);                                                                \
-        put_mtrack((ptr), (size), __FILE__, __LINE__);                               \
+        put_mem_track((ptr), (size), __FILE__, __LINE__);                            \
         atomic_sub(size, &obd_memory);                                               \
         CDEBUG(D_MALLOC, "kfreed '" #ptr "': %d at %p (tot %d).\n",                  \
                (int)(size), ptr, atomic_read(&obd_memory));                          \
@@ -486,7 +486,7 @@ do {
 # define OBD_VFREE(ptr, size)                                                        \
 do {                                                                                 \
         LASSERT(ptr);                                                                \
-        put_mtrack((ptr), (size), __FILE__, __LINE__);                               \
+        put_mem_track((ptr), (size), __FILE__, __LINE__);                            \
         atomic_sub(size, &obd_memory);                                               \
         CDEBUG(D_MALLOC, "vfreed '" #ptr "': %d at %p (tot %d).\n",                  \
                (int)(size), ptr, atomic_read(&obd_memory));                          \
@@ -515,7 +515,7 @@ do {
                 atomic_add(size, &obd_memory);                                        \
                 if (atomic_read(&obd_memory) > obd_memmax)                            \
                         obd_memmax = atomic_read(&obd_memory);                        \
-                get_mtrack((ptr), (size), __FILE__, __LINE__);                        \
+                get_mem_track((ptr), (size), __FILE__, __LINE__);                     \
                 CDEBUG(D_MALLOC, "slab-alloced '"#ptr"': %d at %p (tot %d)\n",        \
                        (int)(size), ptr, atomic_read(&obd_memory));                   \
         }                                                                             \
@@ -526,7 +526,7 @@ do {
         LASSERT(ptr);                                                                 \
         CDEBUG(D_MALLOC, "slab-freed '" #ptr "': %d at %p (tot %d).\n",               \
                (int)(size), ptr, atomic_read(&obd_memory));                           \
-        put_mtrack((ptr), (size), __FILE__, __LINE__);                                \
+        put_mem_track((ptr), (size), __FILE__, __LINE__);                             \
         atomic_sub(size, &obd_memory);                                                \
         POISON(ptr, 0x5a, size);                                                      \
         kmem_cache_free(slab, ptr);                                                   \

diff --git a/lustre/llite/llite_gns.c b/lustre/llite/llite_gns.c
index bf36866..b703532 100644 (file)
--- a/lustre/llite/llite_gns.c
+++ b/lustre/llite/llite_gns.c
@@ -244,7 +244,7 @@ ll_gns_mount_object(struct dentry *dentry, struct vfsmount *mnt)
         }
 
         /*
-         * wait for mount completion. This is actually not need, because
+         * wait for mount completion. This is actually not needed, because
          * USERMODEHELPER() returns only when usermode process finishes. But we
          * doing this just for case USERMODEHELPER() semantics will be changed
          * or usermode upcall program will start mounting in backgound and

diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index c4b54a2..181d956 100644 (file)
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -1070,6 +1070,7 @@ int ll_setattr_raw(struct inode *inode, struct iattr *attr)
                 CDEBUG(D_INODE, "setting mtime %lu, ctime %lu, now = %lu\n",
                        LTIME_S(attr->ia_mtime), LTIME_S(attr->ia_ctime),
                        LTIME_S(CURRENT_TIME));
+
         if (lsm)
                 attr->ia_valid &= ~ATTR_SIZE;
 

diff --git a/lustre/llite/super25.c b/lustre/llite/super25.c
index d026bfd..c3210ad 100644 (file)
--- a/lustre/llite/super25.c
+++ b/lustre/llite/super25.c
@@ -108,7 +108,6 @@ struct super_operations lustre_super_operations =
         .umount_begin  = ll_umount_begin
 };
 
-
 struct file_system_type lustre_lite_fs_type = {
         .owner        = THIS_MODULE,
         .name         = "lustre_lite",

diff --git a/lustre/lvfs/lvfs_linux.c b/lustre/lvfs/lvfs_linux.c
index b981fe9..599adb4 100644 (file)
--- a/lustre/lvfs/lvfs_linux.c
+++ b/lustre/lvfs/lvfs_linux.c
@@ -442,7 +442,7 @@ static int lvfs_memdbg_init(int size)
         LASSERT(size > sizeof(sizeof(struct hlist_head)));
         obd_memtable_size = size / sizeof(struct hlist_head);
 
-        CWARN("Allocating %lu malloc entries...\n",
+        CWARN("allocating %lu malloc entries...\n",
               (unsigned long)obd_memtable_size);
 
         obd_memtable = kmalloc(size, GFP_KERNEL);
@@ -464,13 +464,13 @@ static int lvfs_memdbg_cleanup(void)
 {
         struct hlist_node *node = NULL, *tmp = NULL;
         struct hlist_head *head;
-        struct mtrack *mt;
+        struct mem_track *mt;
         int i;
 
         spin_lock(&obd_memlist_lock);
         for (i = 0, head = obd_memtable; i < obd_memtable_size; i++, head++) {
                 hlist_for_each_safe(node, tmp, head) {
-                        mt = hlist_entry(node, struct mtrack, m_hash);
+                        mt = hlist_entry(node, struct mem_track, m_hash);
                         hlist_del_init(&mt->m_hash);
                         kfree(mt);
                 }
@@ -486,14 +486,14 @@ static inline unsigned long const hashfn(void *ptr)
                 (obd_memtable_size - 1);
 }
 
-static void __lvfs_memdbg_insert(struct mtrack *mt)
+static void __lvfs_memdbg_insert(struct mem_track *mt)
 {
         struct hlist_head *head = obd_memtable +
                 hashfn(mt->m_ptr);
         hlist_add_head(&mt->m_hash, head);
 }
 
-void lvfs_memdbg_insert(struct mtrack *mt)
+void lvfs_memdbg_insert(struct mem_track *mt)
 {
         spin_lock(&obd_memlist_lock);
         __lvfs_memdbg_insert(mt);
@@ -501,12 +501,12 @@ void lvfs_memdbg_insert(struct mtrack *mt)
 }
 EXPORT_SYMBOL(lvfs_memdbg_insert);
 
-static void __lvfs_memdbg_remove(struct mtrack *mt)
+static void __lvfs_memdbg_remove(struct mem_track *mt)
 {
         hlist_del_init(&mt->m_hash);
 }
 
-void lvfs_memdbg_remove(struct mtrack *mt)
+void lvfs_memdbg_remove(struct mem_track *mt)
 {
         spin_lock(&obd_memlist_lock);
         __lvfs_memdbg_remove(mt);
@@ -514,16 +514,16 @@ void lvfs_memdbg_remove(struct mtrack *mt)
 }
 EXPORT_SYMBOL(lvfs_memdbg_remove);
 
-static struct mtrack *__lvfs_memdbg_find(void *ptr)
+static struct mem_track *__lvfs_memdbg_find(void *ptr)
 {
         struct hlist_node *node = NULL;
-        struct mtrack *mt = NULL;
+        struct mem_track *mt = NULL;
         struct hlist_head *head;
 
         head = obd_memtable + hashfn(ptr);
 
         hlist_for_each(node, head) {
-                mt = hlist_entry(node, struct mtrack, m_hash);
+                mt = hlist_entry(node, struct mem_track, m_hash);
                 if ((unsigned long)mt->m_ptr == (unsigned long)ptr)
                         break;
                 mt = NULL;
@@ -531,9 +531,9 @@ static struct mtrack *__lvfs_memdbg_find(void *ptr)
         return mt;
 }
 
-struct mtrack *lvfs_memdbg_find(void *ptr)
+struct mem_track *lvfs_memdbg_find(void *ptr)
 {
-        struct mtrack *mt;
+        struct mem_track *mt;
 
         spin_lock(&obd_memlist_lock);
         mt = __lvfs_memdbg_find(ptr);
@@ -543,7 +543,7 @@ struct mtrack *lvfs_memdbg_find(void *ptr)
 }
 EXPORT_SYMBOL(lvfs_memdbg_find);
 
-int lvfs_memdbg_check_insert(struct mtrack *mt)
+int lvfs_memdbg_check_insert(struct mem_track *mt)
 {
         spin_lock(&obd_memlist_lock);
         if (!__lvfs_memdbg_find(mt->m_ptr)) {
@@ -556,10 +556,10 @@ int lvfs_memdbg_check_insert(struct mtrack *mt)
 }
 EXPORT_SYMBOL(lvfs_memdbg_check_insert);
 
-struct mtrack *
+struct mem_track *
 lvfs_memdbg_check_remove(void *ptr)
 {
-        struct mtrack *mt;
+        struct mem_track *mt;
 
         spin_lock(&obd_memlist_lock);
         mt = __lvfs_memdbg_find(ptr);
@@ -572,32 +572,40 @@ lvfs_memdbg_check_remove(void *ptr)
         return NULL;
 }
 EXPORT_SYMBOL(lvfs_memdbg_check_remove);
+#endif
 
 static void lvfs_memdbg_show(void)
 {
+#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__)
         struct hlist_node *node = NULL;
         struct hlist_head *head;
-        struct mtrack *mt;
-        int leaked, i;
+        struct mem_track *mt;
+#endif
+        int leaked;
+       
+#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__)
+       int i;
+#endif
 
         leaked = atomic_read(&obd_memory);
 
         if (leaked > 0) {
-                CWARN("Memory leaks detected (max %d, leaked %d):\n",
+                CWARN("memory leaks detected (max %d, leaked %d)\n",
                       obd_memmax, leaked);
 
+#if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__)
                 spin_lock(&obd_memlist_lock);
                 for (i = 0, head = obd_memtable; i < obd_memtable_size; i++, head++) {
                         hlist_for_each(node, head) {
-                                mt = hlist_entry(node, struct mtrack, m_hash);
+                                mt = hlist_entry(node, struct mem_track, m_hash);
                                 CWARN("  ptr: 0x%p, size: %d, src at \"%s\"\n",
                                       mt->m_ptr, mt->m_size, mt->m_loc);
                         }
                 }
                 spin_unlock(&obd_memlist_lock);
+#endif
         }
 }
-#endif
 
 static int __init lvfs_linux_init(void)
 {
@@ -614,9 +622,9 @@ static void __exit lvfs_linux_exit(void)
         ENTRY;
 
         lvfs_mount_list_cleanup();
+        lvfs_memdbg_show();
 
 #if defined (CONFIG_DEBUG_MEMORY) && defined(__KERNEL__)
-        lvfs_memdbg_show();
         lvfs_memdbg_cleanup();
 #endif
         EXIT;