diff --git a/Makefile.am b/Makefile.am
index d9880fb..0b94db4 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -9,6 +9,7 @@
 	activation.cpp \
 	version.cpp \
 	serialize.cpp \
+	watch.cpp \
 	item_updater.cpp \
 	item_updater_main.cpp
 
diff --git a/item_updater_main.cpp b/item_updater_main.cpp
index c6f7dba..0933505 100755
--- a/item_updater_main.cpp
+++ b/item_updater_main.cpp
@@ -1,23 +1,56 @@
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/server/manager.hpp>
+#include <system_error>
 #include "config.h"
 #include "item_updater.hpp"
+#include <phosphor-logging/log.hpp>
+#include "watch.hpp"
 
 int main(int argc, char* argv[])
 {
+    using namespace openpower::software::updater;
+    using namespace phosphor::logging;
     auto bus = sdbusplus::bus::new_default();
 
+    sd_event* loop = nullptr;
+    auto rc = sd_event_default(&loop);
+    if (rc < 0)
+    {
+        log<level::ERR>("Error occurred during the sd_event_default",
+                        entry("RC=%d", rc));
+        return -1;
+    }
+
     // Add sdbusplus ObjectManager.
     sdbusplus::server::manager::manager objManager(bus, SOFTWARE_OBJPATH);
 
-    openpower::software::updater::ItemUpdater updater(bus, SOFTWARE_OBJPATH);
+    ItemUpdater updater(bus, SOFTWARE_OBJPATH);
 
     bus.request_name(BUSNAME_UPDATER);
-
-    while (true)
+    try
     {
-        bus.process_discard();
-        bus.wait();
+        openpower::software::updater::Watch watch(
+                loop,
+                std::bind(std::mem_fn(
+                                  &ItemUpdater::updateFunctionalAssociation),
+                          &updater,
+                          std::placeholders::_1));
+        bus.attach_event(loop, SD_EVENT_PRIORITY_NORMAL);
+        auto rc = sd_event_loop(loop);
+        if (rc < 0)
+        {
+            log<level::ERR>("Error occurred during the sd_event_loop",
+                            entry("RC=%d", rc));
+            return -1;
+        }
     }
+    catch (const std::system_error& e)
+    {
+        log<level::ERR>(e.what());
+        return -1;
+    }
+
+    sd_event_unref(loop);
+
     return 0;
 }
diff --git a/watch.cpp b/watch.cpp
new file mode 100644
index 0000000..da06bbc
--- /dev/null
+++ b/watch.cpp
@@ -0,0 +1,133 @@
+#include <stdexcept>
+#include <cstddef>
+#include <cstring>
+#include <string>
+#include <sys/inotify.h>
+#include <unistd.h>
+#include <experimental/filesystem>
+#include <phosphor-logging/log.hpp>
+#include "config.h"
+#include "watch.hpp"
+
+namespace openpower
+{
+namespace software
+{
+namespace updater
+{
+
+using namespace phosphor::logging;
+namespace fs = std::experimental::filesystem;
+
+Watch::Watch(sd_event* loop,
+             std::function<void(std::string&)> functionalCallback) :
+        functionalCallback(functionalCallback),
+        fd(inotifyInit())
+
+{
+    // Create PNOR_ACTIVE_PATH if doesn't exist.
+    if (!fs::is_directory(PNOR_ACTIVE_PATH))
+    {
+        fs::create_directories(PNOR_ACTIVE_PATH);
+    }
+
+    wd = inotify_add_watch(fd(), PNOR_ACTIVE_PATH, IN_CREATE);
+    if (-1 == wd)
+    {
+        auto error = errno;
+        throw std::system_error(error,
+                                std::generic_category(),
+                                "Error occurred during the inotify_init1");
+    }
+
+    decltype(eventSource.get()) sourcePtr = nullptr;
+    auto rc = sd_event_add_io(loop,
+                              &sourcePtr,
+                              fd(),
+                              EPOLLIN,
+                              callback,
+                              this);
+
+    eventSource.reset(sourcePtr);
+
+    if (0 > rc)
+    {
+        throw std::system_error(-rc,
+                                std::generic_category(),
+                                "Error occurred during the inotify_init1");
+    }
+}
+
+Watch::~Watch()
+{
+    if ((-1 != fd()) && (-1 != wd))
+    {
+        inotify_rm_watch(fd(), wd);
+    }
+}
+
+int Watch::callback(sd_event_source* s,
+                    int fd,
+                    uint32_t revents,
+                    void* userdata)
+{
+    if (!(revents & EPOLLIN))
+    {
+        return 0;
+    }
+
+    constexpr auto maxBytes = 1024;
+    uint8_t buffer[maxBytes];
+    auto bytes = read(fd, buffer, maxBytes);
+    if (0 > bytes)
+    {
+        auto error = errno;
+        throw std::system_error(error,
+                                std::generic_category(),
+                                "failed to read inotify event");
+    }
+
+    auto offset = 0;
+    while (offset < bytes)
+    {
+        auto event = reinterpret_cast<inotify_event*>(&buffer[offset]);
+        // Update the functional association on a RO
+        // active image symlink change
+        fs::path path(PNOR_ACTIVE_PATH);
+        path /= event->name;
+        if (fs::equivalent(path, PNOR_RO_ACTIVE_PATH))
+        {
+            auto target = fs::canonical(path).string();
+
+            // Get the image <id> from the symlink target
+            // for example /media/ro-2a1022fe
+            static const auto PNOR_RO_PREFIX_LEN = strlen(PNOR_RO_PREFIX);
+            auto id = target.substr(PNOR_RO_PREFIX_LEN);
+            auto objPath = std::string{SOFTWARE_OBJPATH} + '/' + id;
+
+            static_cast<Watch*>(userdata)->functionalCallback(objPath);
+        }
+        offset += offsetof(inotify_event, name) + event->len;
+    }
+
+    return 0;
+}
+
+int Watch::inotifyInit()
+{
+    auto fd = inotify_init1(IN_NONBLOCK);
+
+    if (-1 == fd)
+    {
+        auto error = errno;
+        throw std::system_error(error,
+                                std::generic_category(),
+                                "Error occurred during the inotify_init1");
+    }
+
+    return fd;
+}
+
+} // namespace updater
+} // namespace software
+} // namespace openpower
diff --git a/watch.hpp b/watch.hpp
new file mode 100644
index 0000000..bdea792
--- /dev/null
+++ b/watch.hpp
@@ -0,0 +1,123 @@
+#pragma once
+
+#include <systemd/sd-event.h>
+#include <unistd.h>
+
+namespace openpower
+{
+namespace software
+{
+namespace updater
+{
+
+/* Need a custom deleter for freeing up sd_event_source */
+struct EventSourceDeleter
+{
+    void operator()(sd_event_source* eventSource) const
+    {
+        eventSource = sd_event_source_unref(eventSource);
+    }
+};
+using EventSourcePtr = std::unique_ptr<sd_event_source, EventSourceDeleter>;
+
+/** @struct CustomFd
+ *
+ *  RAII wrapper for file descriptor.
+ */
+struct CustomFd
+{
+    public:
+        CustomFd() = delete;
+        CustomFd(const CustomFd&) = delete;
+        CustomFd& operator=(const CustomFd&) = delete;
+        CustomFd(CustomFd&&) = delete;
+        CustomFd& operator=(CustomFd&&) = delete;
+
+        /** @brief Saves File descriptor and uses it to do file operation
+         *
+         *  @param[in] fd - File descriptor
+         */
+        CustomFd(int fd) : fd(fd) {}
+
+        ~CustomFd()
+        {
+            if (fd >= 0)
+            {
+                close(fd);
+            }
+        }
+
+        int operator()() const
+        {
+            return fd;
+        }
+
+    private:
+        /** @brief File descriptor */
+        int fd = -1;
+};
+
+/** @class Watch
+ *
+ *  @brief Adds inotify watch on PNOR symlinks file to monitor for changes in
+ *         "running" PNOR version
+ *
+ *  The inotify watch is hooked up with sd-event, so that on call back,
+ *  appropriate actions related to a change in the "running" PNOR version
+ *  can be taken.
+ */
+class Watch
+{
+    public:
+        /** @brief ctor - hook inotify watch with sd-event
+         *
+         *  @param[in] loop - sd-event object
+         *  @param[in] functionalCallback - The callback function for updating
+         *                                  the functional associations.
+         */
+        Watch(sd_event* loop,
+              std::function<void(std::string&)> functionalCallback);
+
+        Watch(const Watch&) = delete;
+        Watch& operator=(const Watch&) = delete;
+        Watch(Watch&&) = delete;
+        Watch& operator=(Watch&&) = delete;
+
+        /** @brief dtor - remove inotify watch
+         */
+        ~Watch();
+
+    private:
+        /** @brief sd-event callback
+         *
+         *  @param[in] s - event source, floating (unused) in our case
+         *  @param[in] fd - inotify fd
+         *  @param[in] revents - events that matched for fd
+         *  @param[in] userdata - pointer to Watch object
+         *  @returns 0 on success, -1 on fail
+         */
+        static int callback(sd_event_source* s,
+                            int fd,
+                            uint32_t revents,
+                            void* userdata);
+
+        /**  initialize an inotify instance and returns file descriptor */
+        int inotifyInit();
+
+        /** @brief PNOR symlink file watch descriptor */
+        int wd = -1;
+
+        /** @brief event source */
+        EventSourcePtr eventSource;
+
+        /** @brief The callback function for updating the
+                   functional associations. */
+        std::function<void(std::string&)> functionalCallback;
+
+        /** @brief inotify file descriptor */
+        CustomFd fd;
+};
+
+} // namespace updater
+} // namespace software
+} // namespace openpower