/*

 * Copyright (c) 2020 Red Hat, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA. 

 *

 * $Id: //eng/vdo-releases/aluminum/src/c++/vdo/kernel/statusProcfs.c#4 $

 *

 * Proc filesystem interface to the old GET_DEDUPE_STATS and

 * GET_KERNEL_STATS ioctls, which can no longer be supported in 4.4

 * and later kernels. These files return the same data as the old

 * ioctls do, in order to require minimal changes to our (and

 * customers') utilties and test code.

 *

 * +--+-----  /proc/vdo           procfsRoot

 *    |

 *    +-+-----  vdo<n>            config->poolName

 *      |

 *      +-------  dedupe_stats    GET_DEDUPE_STATS ioctl

 *      +-------  kernel_stats    GET_KERNEL_STATS ioctl

 *

 */

#include "statusProcfs.h"

#include <linux/version.h>

#include "memoryAlloc.h"

#include "releaseVersions.h"

#include "statistics.h"

#include "vdo.h"

#include "dedupeIndex.h"

#include "ioSubmitter.h"

#include "kernelStatistics.h"

#include "logger.h"

#include "memoryUsage.h"

#include "threadDevice.h"

#include "vdoCommon.h"

static struct proc_dir_entry *procfsRoot = NULL;

/**********************************************************************/

static int statusDedupeShow(struct seq_file *m, void *v)

{

  KernelLayer *layer = (KernelLayer *) m->private;

  VDOStatistics *stats;

  size_t len = sizeof(VDOStatistics);

  RegisteredThread allocatingThread, instanceThread;

  registerAllocatingThread(&allocatingThread, NULL);

  registerThreadDevice(&instanceThread, layer);

  int result = ALLOCATE(1, VDOStatistics, __func__, &stats);

  if (result == VDO_SUCCESS) {

    getKVDOStatistics(&layer->kvdo, stats);

    seq_write(m, stats, len);

    FREE(stats);

  }

  unregisterThreadDeviceID();

  unregisterAllocatingThread();

  return result;

}

/**********************************************************************/

static int statusDedupeOpen(struct inode *inode, struct file *file)

{

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)

  return single_open(file, statusDedupeShow, PDE_DATA(inode));

#else

  return single_open(file, statusDedupeShow, PDE(inode)->data);

#endif

}

static const struct file_operations vdoProcfsDedupeOps = {

  .open = statusDedupeOpen,

  .read = seq_read,

  .llseek = seq_lseek,

  .release = single_release,

};

/**********************************************************************/

static void copyBioStat(BioStats *b, const AtomicBioStats *a)

{

  b->read    = atomic64_read(&a->read);

  b->write   = atomic64_read(&a->write);

  b->discard = atomic64_read(&a->discard);

  b->flush   = atomic64_read(&a->flush);

  b->fua     = atomic64_read(&a->fua);

}

/**********************************************************************/

static BioStats subtractBioStats(BioStats minuend, BioStats subtrahend)

{

  return (BioStats) {

    .read    = minuend.read - subtrahend.read,

    .write   = minuend.write - subtrahend.write,

    .discard = minuend.discard - subtrahend.discard,

    .flush   = minuend.flush - subtrahend.flush,

    .fua     = minuend.fua - subtrahend.fua,

  };

}

/**********************************************************************/

void getKernelStats(KernelLayer *layer, KernelStatistics *stats)

{

  stats->version        = STATISTICS_VERSION;

  stats->releaseVersion = CURRENT_RELEASE_VERSION_NUMBER;

  stats->instance       = layer->instance;

  getLimiterValuesAtomically(&layer->requestLimiter,

                             &stats->currentVIOsInProgress, &stats->maxVIOs);

  // albireoTimeoutReport gives the number of timeouts, and dedupeContextBusy

  // gives the number of queries not made because of earlier timeouts.

  stats->dedupeAdviceTimeouts = (getEventCount(&layer->albireoTimeoutReporter)

                                 + atomic64_read(&layer->dedupeContextBusy));

  stats->flushOut             = atomic64_read(&layer->flushOut);

  stats->logicalBlockSize     = layer->deviceConfig->logicalBlockSize;

  copyBioStat(&stats->biosIn, &layer->biosIn);

  copyBioStat(&stats->biosInPartial, &layer->biosInPartial);

  copyBioStat(&stats->biosOut, &layer->biosOut);

  copyBioStat(&stats->biosMeta, &layer->biosMeta);

  copyBioStat(&stats->biosJournal, &layer->biosJournal);

  copyBioStat(&stats->biosPageCache, &layer->biosPageCache);

  copyBioStat(&stats->biosOutCompleted, &layer->biosOutCompleted);

  copyBioStat(&stats->biosMetaCompleted, &layer->biosMetaCompleted);

  copyBioStat(&stats->biosJournalCompleted, &layer->biosJournalCompleted);

  copyBioStat(&stats->biosPageCacheCompleted,

              &layer->biosPageCacheCompleted);

  copyBioStat(&stats->biosAcknowledged, &layer->biosAcknowledged);

  copyBioStat(&stats->biosAcknowledgedPartial,

              &layer->biosAcknowledgedPartial);

  stats->biosInProgress = subtractBioStats(stats->biosIn,

                                           stats->biosAcknowledged);

  stats->memoryUsage = getMemoryUsage();

  getIndexStatistics(layer->dedupeIndex, &stats->index);

}

/**********************************************************************/

static int statusKernelShow(struct seq_file *m, void *v)

{

  KernelLayer *layer = (KernelLayer *) m->private;

  KernelStatistics *stats;

  size_t len = sizeof(KernelStatistics);

  RegisteredThread allocatingThread, instanceThread;

  registerAllocatingThread(&allocatingThread, NULL);

  registerThreadDevice(&instanceThread, layer);

  int result = ALLOCATE(1, KernelStatistics, __func__, &stats);

  if (result == VDO_SUCCESS) {

    getKernelStats(layer, stats);

    seq_write(m, stats, len);

    FREE(stats);

  }

  unregisterThreadDeviceID();

  unregisterAllocatingThread();

  return result;

}

/**********************************************************************/

static int statusKernelOpen(struct inode *inode, struct file *file)

{

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)

  return single_open(file, statusKernelShow, PDE_DATA(inode));

#else

  return single_open(file, statusKernelShow, PDE(inode)->data);

#endif

}

static const struct file_operations vdoProcfsKernelOps = {

  .open = statusKernelOpen,

  .read = seq_read,

  .llseek = seq_lseek,

  .release = single_release,

};

/**********************************************************************/

int vdoInitProcfs()

{

  const char *procfsName = getProcRoot();

  procfsRoot = proc_mkdir(procfsName, NULL);

  if (procfsRoot == NULL) {

    logWarning("Could not create proc filesystem root %s\n", procfsName);

    return -ENOMEM;

  }

  return VDO_SUCCESS;

}

/**********************************************************************/

void vdoDestroyProcfs()

{

  remove_proc_entry(getProcRoot(), NULL);

  procfsRoot = NULL;

}

/**********************************************************************/

int vdoCreateProcfsEntry(KernelLayer *layer, const char *name, void **private)

{

  int result = VDO_SUCCESS;

  if (procfsRoot != NULL) {

    struct proc_dir_entry *fsDir;

    fsDir = proc_mkdir(name, procfsRoot);

    if (fsDir == NULL) {

      result = -ENOMEM;

    } else {

      if (proc_create_data(getVDOStatisticsProcFile(), 0644, fsDir,

                           &vdoProcfsDedupeOps, layer) == NULL) {

        result = -ENOMEM;

      } else if (proc_create_data(getKernelStatisticsProcFile(), 0644, fsDir,

                                  &vdoProcfsKernelOps, layer) == NULL) {

        result = -ENOMEM;

      }

    }

    if (result < 0) {

      vdoDestroyProcfsEntry(name, fsDir);

    } else {

      *private = fsDir;

    }

  } else {

    logWarning("No proc filesystem root set, skipping %s\n", name);

  }

  return result;

}

/**********************************************************************/

void vdoDestroyProcfsEntry(const char *name, void *private)

{

  if (procfsRoot != NULL) {

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)

    remove_proc_subtree(name, procfsRoot);

#else

    struct proc_dir_entry *fsDir = (struct proc_dir_entry *) private;

    remove_proc_entry(getVDOStatisticsProcFile(), fsDir);

    remove_proc_entry(getKernelStatisticsProcFile(), fsDir);

    remove_proc_entry(name, procfsRoot);

#endif

  }

}