fscache: Add tracepoints

Add some tracepoints to fscache:

 (*) fscache_cookie - Tracks a cookie's usage count.

 (*) fscache_netfs - Logs registration of a network filesystem, including
     the pointer to the cookie allocated.

 (*) fscache_acquire - Logs cookie acquisition.

 (*) fscache_relinquish - Logs cookie relinquishment.

 (*) fscache_enable - Logs enablement of a cookie.

 (*) fscache_disable - Logs disablement of a cookie.

 (*) fscache_osm - Tracks execution of states in the object state machine.

and cachefiles:

 (*) cachefiles_ref - Tracks a cachefiles object's usage count.

 (*) cachefiles_lookup - Logs result of lookup_one_len().

 (*) cachefiles_mkdir - Logs result of vfs_mkdir().

 (*) cachefiles_create - Logs result of vfs_create().

 (*) cachefiles_unlink - Logs calls to vfs_unlink().

 (*) cachefiles_rename - Logs calls to vfs_rename().

 (*) cachefiles_mark_active - Logs an object becoming active.

 (*) cachefiles_wait_active - Logs a wait for an old object to be
     destroyed.

 (*) cachefiles_mark_inactive - Logs an object becoming inactive.

 (*) cachefiles_mark_buried - Logs the burial of an object.

Signed-off-by: David Howells <dhowells@redhat.com>

5 files changed, 63 insertions, 39 deletions

diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c
index 98d22f495cd8..20bc3341f113 100644
--- a/fs/fscache/cookie.c
+++ b/fs/fscache/cookie.c
@@ -101,7 +101,7 @@ struct fscache_cookie *__fscache_acquire_cookie(
          */
         atomic_set(&cookie->n_active, 1);
 
-        atomic_inc(&parent->usage);
+        fscache_cookie_get(parent, fscache_cookie_get_acquire_parent);
         atomic_inc(&parent->n_children);
 
         cookie->def             = def;
@@ -125,6 +125,8 @@ struct fscache_cookie *__fscache_acquire_cookie(
                 break;
         }
 
+        trace_fscache_acquire(cookie);
+
         if (enable) {
                 /* if the object is an index then we need do nothing more here
                  * - we create indices on disk when we need them as an index
@@ -134,7 +136,8 @@ struct fscache_cookie *__fscache_acquire_cookie(
                                 set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags);
                         } else {
                                 atomic_dec(&parent->n_children);
-                                __fscache_cookie_put(cookie);
+                                fscache_cookie_put(cookie,
+                                                   fscache_cookie_put_acquire_nobufs);
                                 fscache_stat(&fscache_n_acquires_nobufs);
                                 _leave(" = NULL");
                                 return NULL;
@@ -159,6 +162,8 @@ void __fscache_enable_cookie(struct fscache_cookie *cookie,
 {
         _enter("%p", cookie);
 
+        trace_fscache_enable(cookie);
+
         wait_on_bit_lock(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK,
                          TASK_UNINTERRUPTIBLE);
 
@@ -318,7 +323,7 @@ static int fscache_alloc_object(struct fscache_cache *cache,
          * attached to the cookie */
         if (fscache_attach_object(cookie, object) < 0) {
                 fscache_stat(&fscache_n_cop_put_object);
-                cache->ops->put_object(object);
+                cache->ops->put_object(object, fscache_obj_put_attach_fail);
                 fscache_stat_d(&fscache_n_cop_put_object);
         }
 
@@ -338,7 +343,7 @@ object_already_extant:
 
 error_put:
         fscache_stat(&fscache_n_cop_put_object);
-        cache->ops->put_object(object);
+        cache->ops->put_object(object, fscache_obj_put_alloc_fail);
         fscache_stat_d(&fscache_n_cop_put_object);
 error:
         _leave(" = %d", ret);
@@ -398,7 +403,7 @@ static int fscache_attach_object(struct fscache_cookie *cookie,
 
         /* attach to the cookie */
         object->cookie = cookie;
-        atomic_inc(&cookie->usage);
+        fscache_cookie_get(cookie, fscache_cookie_get_attach_object);
         hlist_add_head(&object->cookie_link, &cookie->backing_objects);
 
         fscache_objlist_add(object);
@@ -516,6 +521,8 @@ void __fscache_disable_cookie(struct fscache_cookie *cookie, bool invalidate)
 
         _enter("%p,%u", cookie, invalidate);
 
+        trace_fscache_disable(cookie);
+
         ASSERTCMP(atomic_read(&cookie->n_active), >, 0);
 
         if (atomic_read(&cookie->n_children) != 0) {
@@ -601,6 +608,8 @@ void __fscache_relinquish_cookie(struct fscache_cookie *cookie, bool retire)
                cookie, cookie->def->name, cookie->netfs_data,
                atomic_read(&cookie->n_active), retire);
 
+        trace_fscache_relinquish(cookie, retire);
+
         /* No further netfs-accessing operations on this cookie permitted */
         if (test_and_set_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags))
                 BUG();
@@ -620,35 +629,38 @@ void __fscache_relinquish_cookie(struct fscache_cookie *cookie, bool retire)
 
         /* Dispose of the netfs's link to the cookie */
         ASSERTCMP(atomic_read(&cookie->usage), >, 0);
-        fscache_cookie_put(cookie);
+        fscache_cookie_put(cookie, fscache_cookie_put_relinquish);
 
         _leave("");
 }
 EXPORT_SYMBOL(__fscache_relinquish_cookie);
 
 /*
- * destroy a cookie
+ * Drop a reference to a cookie.
  */
-void __fscache_cookie_put(struct fscache_cookie *cookie)
+void fscache_cookie_put(struct fscache_cookie *cookie,
+                        enum fscache_cookie_trace where)
 {
         struct fscache_cookie *parent;
+        int usage;
 
         _enter("%p", cookie);
 
-        for (;;) {
-                _debug("FREE COOKIE %p", cookie);
+        do {
+                usage = atomic_dec_return(&cookie->usage);
+                trace_fscache_cookie(cookie, where, usage);
+
+                if (usage > 0)
+                        return;
+                BUG_ON(usage < 0);
+
                 parent = cookie->parent;
                 BUG_ON(!hlist_empty(&cookie->backing_objects));
                 kmem_cache_free(fscache_cookie_jar, cookie);
 
-                if (!parent)
-                        break;
-
                 cookie = parent;
-                BUG_ON(atomic_read(&cookie->usage) <= 0);
-                if (!atomic_dec_and_test(&cookie->usage))
-                        break;
-        }
+                where = fscache_cookie_put_parent;
+        } while (cookie);
 
         _leave("");
 }
diff --git a/fs/fscache/internal.h b/fs/fscache/internal.h
index 0ff4b49a0037..c27e2db3004e 100644
--- a/fs/fscache/internal.h
+++ b/fs/fscache/internal.h
@@ -29,6 +29,7 @@
 #define pr_fmt(fmt) "FS-Cache: " fmt
 
 #include <linux/fscache-cache.h>
+#include <trace/events/fscache.h>
 #include <linux/sched.h>
 
 #define FSCACHE_MIN_THREADS     4
@@ -49,7 +50,8 @@ extern struct fscache_cache *fscache_select_cache_for_object(
 extern struct kmem_cache *fscache_cookie_jar;
 
 extern void fscache_cookie_init_once(void *);
-extern void __fscache_cookie_put(struct fscache_cookie *);
+extern void fscache_cookie_put(struct fscache_cookie *,
+                               enum fscache_cookie_trace);
 
 /*
  * fsdef.c
@@ -311,14 +313,12 @@ static inline void fscache_raise_event(struct fscache_object *object,
                 fscache_enqueue_object(object);
 }
 
-/*
- * drop a reference to a cookie
- */
-static inline void fscache_cookie_put(struct fscache_cookie *cookie)
+static inline void fscache_cookie_get(struct fscache_cookie *cookie,
+                                      enum fscache_cookie_trace where)
 {
-        BUG_ON(atomic_read(&cookie->usage) <= 0);
-        if (atomic_dec_and_test(&cookie->usage))
-                __fscache_cookie_put(cookie);
+        int usage = atomic_inc_return(&cookie->usage);
+
+        trace_fscache_cookie(cookie, where, usage);
 }
 
 /*
diff --git a/fs/fscache/main.c b/fs/fscache/main.c
index 249968dcbf5c..7dce110bf17d 100644
--- a/fs/fscache/main.c
+++ b/fs/fscache/main.c
@@ -16,6 +16,7 @@
 #include <linux/completion.h>
 #include <linux/slab.h>
 #include <linux/seq_file.h>
+#define CREATE_TRACE_POINTS
 #include "internal.h"
 
 MODULE_DESCRIPTION("FS Cache Manager");
diff --git a/fs/fscache/netfs.c b/fs/fscache/netfs.c
index a8aa00be4444..c816600d1dde 100644
--- a/fs/fscache/netfs.c
+++ b/fs/fscache/netfs.c
@@ -60,7 +60,7 @@ int __fscache_register_netfs(struct fscache_netfs *netfs)
                         goto already_registered;
         }
 
-        atomic_inc(&cookie->parent->usage);
+        fscache_cookie_get(cookie->parent, fscache_cookie_get_register_netfs);
         atomic_inc(&cookie->parent->n_children);
 
         netfs->primary_index = cookie;
@@ -68,6 +68,7 @@ int __fscache_register_netfs(struct fscache_netfs *netfs)
         ret = 0;
 
         pr_notice("Netfs '%s' registered for caching\n", netfs->name);
+        trace_fscache_netfs(netfs);
 
 already_registered:
         up_write(&fscache_addremove_sem);
diff --git a/fs/fscache/object.c b/fs/fscache/object.c
index 7a182c87f378..99afe64352a5 100644
--- a/fs/fscache/object.c
+++ b/fs/fscache/object.c
@@ -138,8 +138,10 @@ static const struct fscache_transition fscache_osm_run_oob[] = {
            { 0, NULL }
 };
 
-static int  fscache_get_object(struct fscache_object *);
-static void fscache_put_object(struct fscache_object *);
+static int  fscache_get_object(struct fscache_object *,
+                               enum fscache_obj_ref_trace);
+static void fscache_put_object(struct fscache_object *,
+                               enum fscache_obj_ref_trace);
 static bool fscache_enqueue_dependents(struct fscache_object *, int);
 static void fscache_dequeue_object(struct fscache_object *);
 
@@ -170,6 +172,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
         const struct fscache_transition *t;
         const struct fscache_state *state, *new_state;
         unsigned long events, event_mask;
+        bool oob;
         int event = -1;
 
         ASSERT(object != NULL);
@@ -188,6 +191,7 @@ restart_masked:
         if (events & object->oob_event_mask) {
                 _debug("{OBJ%x} oob %lx",
                        object->debug_id, events & object->oob_event_mask);
+                oob = true;
                 for (t = object->oob_table; t->events; t++) {
                         if (events & t->events) {
                                 state = t->transit_to;
@@ -199,6 +203,7 @@ restart_masked:
                         }
                 }
         }
+        oob = false;
 
         /* Wait states are just transition tables */
         if (!state->work) {
@@ -207,6 +212,8 @@ restart_masked:
                                 if (events & t->events) {
                                         new_state = t->transit_to;
                                         event = fls(events & t->events) - 1;
+                                        trace_fscache_osm(object, state,
+                                                          true, false, event);
                                         clear_bit(event, &object->events);
                                         _debug("{OBJ%x} ev %d: %s -> %s",
                                                object->debug_id, event,
@@ -226,6 +233,7 @@ restart_masked:
 execute_work_state:
         _debug("{OBJ%x} exec %s", object->debug_id, state->name);
 
+        trace_fscache_osm(object, state, false, oob, event);
         new_state = state->work(object, event);
         event = -1;
         if (new_state == NO_TRANSIT) {
@@ -279,7 +287,7 @@ static void fscache_object_work_func(struct work_struct *work)
         start = jiffies;
         fscache_object_sm_dispatcher(object);
         fscache_hist(fscache_objs_histogram, start);
-        fscache_put_object(object);
+        fscache_put_object(object, fscache_obj_put_work);
 }
 
 /**
@@ -397,7 +405,7 @@ static const struct fscache_state *fscache_initialise_object(struct fscache_obje
         fscache_stat(&fscache_n_cop_grab_object);
         success = false;
         if (fscache_object_is_live(parent) &&
-            object->cache->ops->grab_object(object)) {
+            object->cache->ops->grab_object(object, fscache_obj_get_add_to_deps)) {
                 list_add(&object->dep_link, &parent->dependents);
                 success = true;
         }
@@ -745,7 +753,7 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob
         }
 
         /* this just shifts the object release to the work processor */
-        fscache_put_object(object);
+        fscache_put_object(object, fscache_obj_put_drop_obj);
         fscache_stat(&fscache_n_object_dead);
 
         _leave("");
@@ -755,12 +763,13 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob
 /*
  * get a ref on an object
  */
-static int fscache_get_object(struct fscache_object *object)
+static int fscache_get_object(struct fscache_object *object,
+                              enum fscache_obj_ref_trace why)
 {
         int ret;
 
         fscache_stat(&fscache_n_cop_grab_object);
-        ret = object->cache->ops->grab_object(object) ? 0 : -EAGAIN;
+        ret = object->cache->ops->grab_object(object, why) ? 0 : -EAGAIN;
         fscache_stat_d(&fscache_n_cop_grab_object);
         return ret;
 }
@@ -768,10 +777,11 @@ static int fscache_get_object(struct fscache_object *object)
 /*
  * Discard a ref on an object
  */
-static void fscache_put_object(struct fscache_object *object)
+static void fscache_put_object(struct fscache_object *object,
+                               enum fscache_obj_ref_trace why)
 {
         fscache_stat(&fscache_n_cop_put_object);
-        object->cache->ops->put_object(object);
+        object->cache->ops->put_object(object, why);
         fscache_stat_d(&fscache_n_cop_put_object);
 }
 
@@ -786,7 +796,7 @@ void fscache_object_destroy(struct fscache_object *object)
         fscache_objlist_remove(object);
 
         /* We can get rid of the cookie now */
-        fscache_cookie_put(object->cookie);
+        fscache_cookie_put(object->cookie, fscache_cookie_put_object);
         object->cookie = NULL;
 }
 EXPORT_SYMBOL(fscache_object_destroy);
@@ -798,7 +808,7 @@ void fscache_enqueue_object(struct fscache_object *object)
 {
         _enter("{OBJ%x}", object->debug_id);
 
-        if (fscache_get_object(object) >= 0) {
+        if (fscache_get_object(object, fscache_obj_get_queue) >= 0) {
                 wait_queue_head_t *cong_wq =
                         &get_cpu_var(fscache_object_cong_wait);
 
@@ -806,7 +816,7 @@ void fscache_enqueue_object(struct fscache_object *object)
                         if (fscache_object_congested())
                                 wake_up(cong_wq);
                 } else
-                        fscache_put_object(object);
+                        fscache_put_object(object, fscache_obj_put_queue);
 
                 put_cpu_var(fscache_object_cong_wait);
         }
@@ -866,7 +876,7 @@ static bool fscache_enqueue_dependents(struct fscache_object *object, int event)
                 list_del_init(&dep->dep_link);
 
                 fscache_raise_event(dep, event);
-                fscache_put_object(dep);
+                fscache_put_object(dep, fscache_obj_put_enq_dep);
 
                 if (!list_empty(&object->dependents) && need_resched()) {
                         ret = false;