lustre/obdclass/lprocfs_jobstats.c

   1 /* GPL HEADER START
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License version 2 for more details (a copy is included
  13  * in the LICENSE file that accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * version 2 along with this program; If not, see
  17  * http://www.gnu.org/licenses/gpl-2.0.html
  18  *
  19  * GPL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2012, 2016, Intel Corporation.
  23  * Use is subject to license terms.
  24  *
  25  * Author: Niu Yawei <niu@whamcloud.com>
  26  */
  27 /*
  28  * lustre/obdclass/lprocfs_jobstats.c
  29  */
  30
  31 #define DEBUG_SUBSYSTEM S_CLASS
  32
  33 #include <obd_class.h>
  34 #include <lprocfs_status.h>
  35
  36 #ifdef CONFIG_PROC_FS
  37
  38 /*
  39  * JobID formats & JobID environment variable names for supported
  40  * job schedulers:
  41  *
  42  * SLURM:
  43  *   JobID format:  32 bit integer.
  44  *   JobID env var: SLURM_JOB_ID.
  45  * SGE:
  46  *   JobID format:  Decimal integer range to 99999.
  47  *   JobID env var: JOB_ID.
  48  * LSF:
  49  *   JobID format:  6 digit integer by default (up to 999999), can be
  50  *                increased to 10 digit (up to 2147483646).
  51  *   JobID env var: LSB_JOBID.
  52  * Loadleveler:
  53  *   JobID format:  String of machine_name.cluster_id.process_id, for
  54  *                example: fr2n02.32.0
  55  *   JobID env var: LOADL_STEP_ID.
  56  * PBS:
  57  *   JobID format:  String of sequence_number[.server_name][@server].
  58  *   JobID env var: PBS_JOBID.
  59  * Maui/MOAB:
  60  *   JobID format:  Same as PBS.
  61  *   JobID env var: Same as PBS.
  62  */
  63
  64 struct job_stat {
  65         struct hlist_node       js_hash;        /* hash struct for this jobid */
  66         struct list_head        js_list;        /* on ojs_list, with ojs_lock */
  67         atomic_t                js_refcount;    /* num users of this struct */
  68         char                    js_jobid[LUSTRE_JOBID_SIZE]; /* job name + NUL*/
  69         ktime_t                 js_time_init;   /* time of initial stat*/
  70         ktime_t                 js_time_latest; /* time of most recent stat*/
  71         struct lprocfs_stats    *js_stats;      /* per-job statistics */
  72         struct obd_job_stats    *js_jobstats;   /* for accessing ojs_lock */
  73 };
  74
  75 static unsigned
  76 job_stat_hash(struct cfs_hash *hs, const void *key, unsigned mask)
  77 {
  78         return cfs_hash_djb2_hash(key, strlen(key), mask);
  79 }
  80
  81 static void *job_stat_key(struct hlist_node *hnode)
  82 {
  83         struct job_stat *job;
  84         job = hlist_entry(hnode, struct job_stat, js_hash);
  85         return job->js_jobid;
  86 }
  87
  88 static int job_stat_keycmp(const void *key, struct hlist_node *hnode)
  89 {
  90         struct job_stat *job;
  91         job = hlist_entry(hnode, struct job_stat, js_hash);
  92         return (strlen(job->js_jobid) == strlen(key)) &&
  93                !strncmp(job->js_jobid, key, strlen(key));
  94 }
  95
  96 static void *job_stat_object(struct hlist_node *hnode)
  97 {
  98         return hlist_entry(hnode, struct job_stat, js_hash);
  99 }
 100
 101 static void job_stat_get(struct cfs_hash *hs, struct hlist_node *hnode)
 102 {
 103         struct job_stat *job;
 104         job = hlist_entry(hnode, struct job_stat, js_hash);
 105         atomic_inc(&job->js_refcount);
 106 }
 107
 108 static void job_free(struct job_stat *job)
 109 {
 110         LASSERT(atomic_read(&job->js_refcount) == 0);
 111         LASSERT(job->js_jobstats != NULL);
 112
 113         write_lock(&job->js_jobstats->ojs_lock);
 114         list_del_init(&job->js_list);
 115         write_unlock(&job->js_jobstats->ojs_lock);
 116
 117         lprocfs_free_stats(&job->js_stats);
 118         OBD_FREE_PTR(job);
 119 }
 120
 121 static void job_putref(struct job_stat *job)
 122 {
 123         LASSERT(atomic_read(&job->js_refcount) > 0);
 124         if (atomic_dec_and_test(&job->js_refcount))
 125                 job_free(job);
 126 }
 127
 128 static void job_stat_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
 129 {
 130         struct job_stat *job;
 131         job = hlist_entry(hnode, struct job_stat, js_hash);
 132         job_putref(job);
 133 }
 134
 135 static void job_stat_exit(struct cfs_hash *hs, struct hlist_node *hnode)
 136 {
 137         CERROR("should not have any items\n");
 138 }
 139
 140 static struct cfs_hash_ops job_stats_hash_ops = {
 141         .hs_hash       = job_stat_hash,
 142         .hs_key        = job_stat_key,
 143         .hs_keycmp     = job_stat_keycmp,
 144         .hs_object     = job_stat_object,
 145         .hs_get        = job_stat_get,
 146         .hs_put_locked = job_stat_put_locked,
 147         .hs_exit       = job_stat_exit,
 148 };
 149
 150 /**
 151  * Jobstats expiry iterator to clean up old jobids
 152  *
 153  * Called for each job_stat structure on this device, it should delete stats
 154  * older than the specified \a oldest_time in seconds.  If \a oldest_time is
 155  * in the future then this will delete all statistics (e.g. during shutdown).
 156  *
 157  * \param[in] hs        hash of all jobids on this device
 158  * \param[in] bd        hash bucket containing this jobid
 159  * \param[in] hnode     hash structure for this jobid
 160  * \param[in] data      pointer to stats expiry time in seconds
 161  */
 162 static int job_cleanup_iter_callback(struct cfs_hash *hs,
 163                                      struct cfs_hash_bd *bd,
 164                                      struct hlist_node *hnode, void *data)
 165 {
 166         ktime_t oldest_time = *((ktime_t *)data);
 167         struct job_stat *job;
 168
 169         job = hlist_entry(hnode, struct job_stat, js_hash);
 170         if (ktime_before(job->js_time_latest, oldest_time))
 171                 cfs_hash_bd_del_locked(hs, bd, hnode);
 172
 173         return 0;
 174 }
 175
 176 /**
 177  * Clean up jobstats that were updated more than \a before seconds ago.
 178  *
 179  * Since this function may be called frequently, do not scan all of the
 180  * jobstats on each call, only twice per cleanup interval.  That means stats
 181  * may be on average around cleanup_interval / 4 older than the cleanup
 182  * interval, but that is not considered harmful.
 183  *
 184  * The value stored in ojs_cleanup_interval is how often to perform a cleanup
 185  * scan, and 1/2 of the maximum age of the individual statistics.  This is
 186  * done rather than dividing the interval by two each time, because it is
 187  * much easier to do the division when the value is initially set (in seconds)
 188  * rather than after it has been converted to ktime_t, and maybe a bit faster.
 189  *
 190  * If \a clear is true then this will force clean up all jobstats
 191  * (e.g. at shutdown).
 192  *
 193  * If there is already another thread doing jobstats cleanup, don't try to
 194  * do this again in the current thread unless this is a force cleanup.
 195  *
 196  * \param[in] stats     stucture tracking all job stats for this device
 197  * \param[in] clear     clear all job stats if true
 198  */
 199 static void lprocfs_job_cleanup(struct obd_job_stats *stats, bool clear)
 200 {
 201         ktime_t cleanup_interval = stats->ojs_cleanup_interval;
 202         ktime_t now = ktime_get_real();
 203         ktime_t oldest;
 204
 205         if (likely(!clear)) {
 206                 /* ojs_cleanup_interval of zero means never clean up stats */
 207                 if (ktime_to_ns(cleanup_interval) == 0)
 208                         return;
 209
 210                 if (ktime_before(now, ktime_add(stats->ojs_cleanup_last,
 211                                                 cleanup_interval)))
 212                         return;
 213
 214                 if (stats->ojs_cleaning)
 215                         return;
 216         }
 217
 218         write_lock(&stats->ojs_lock);
 219         if (!clear && stats->ojs_cleaning) {
 220                 write_unlock(&stats->ojs_lock);
 221                 return;
 222         }
 223
 224         stats->ojs_cleaning = true;
 225         write_unlock(&stats->ojs_lock);
 226
 227         /* Can't hold ojs_lock over hash iteration, since it is grabbed by
 228          * job_cleanup_iter_callback()
 229          *   ->cfs_hash_bd_del_locked()
 230          *     ->job_putref()
 231          *       ->job_free()
 232          *
 233          * Holding ojs_lock isn't necessary for safety of the hash iteration,
 234          * since locking of the hash is handled internally, but there isn't
 235          * any benefit to having multiple threads doing cleanup at one time.
 236          *
 237          * Subtract twice the cleanup_interval, since it is 1/2 the maximum age.
 238          */
 239         oldest = ktime_sub(now, ktime_add(cleanup_interval, cleanup_interval));
 240         cfs_hash_for_each_safe(stats->ojs_hash, job_cleanup_iter_callback,
 241                                &oldest);
 242
 243         write_lock(&stats->ojs_lock);
 244         stats->ojs_cleaning = false;
 245         stats->ojs_cleanup_last = ktime_get_real();
 246         write_unlock(&stats->ojs_lock);
 247 }
 248
 249 static struct job_stat *job_alloc(char *jobid, struct obd_job_stats *jobs)
 250 {
 251         struct job_stat *job;
 252
 253         OBD_ALLOC_PTR(job);
 254         if (job == NULL)
 255                 return NULL;
 256
 257         job->js_stats = lprocfs_alloc_stats(jobs->ojs_cntr_num, 0);
 258         if (job->js_stats == NULL) {
 259                 OBD_FREE_PTR(job);
 260                 return NULL;
 261         }
 262
 263         jobs->ojs_cntr_init_fn(job->js_stats, 0);
 264
 265         memcpy(job->js_jobid, jobid, sizeof(job->js_jobid));
 266         job->js_time_latest = job->js_stats->ls_init;
 267         job->js_jobstats = jobs;
 268         INIT_HLIST_NODE(&job->js_hash);
 269         INIT_LIST_HEAD(&job->js_list);
 270         atomic_set(&job->js_refcount, 1);
 271
 272         return job;
 273 }
 274
 275 int lprocfs_job_stats_log(struct obd_device *obd, char *jobid,
 276                           int event, long amount)
 277 {
 278         struct obd_job_stats *stats = &obd->u.obt.obt_jobstats;
 279         struct job_stat *job, *job2;
 280         ENTRY;
 281
 282         LASSERT(stats != NULL);
 283         LASSERT(stats->ojs_hash != NULL);
 284
 285         if (event >= stats->ojs_cntr_num)
 286                 RETURN(-EINVAL);
 287
 288         if (jobid == NULL || strlen(jobid) == 0)
 289                 RETURN(-EINVAL);
 290
 291         if (strlen(jobid) >= LUSTRE_JOBID_SIZE) {
 292                 CERROR("Invalid jobid size (%lu), expect(%d)\n",
 293                        (unsigned long)strlen(jobid) + 1, LUSTRE_JOBID_SIZE);
 294                 RETURN(-EINVAL);
 295         }
 296
 297         job = cfs_hash_lookup(stats->ojs_hash, jobid);
 298         if (job)
 299                 goto found;
 300
 301         lprocfs_job_cleanup(stats, false);
 302
 303         job = job_alloc(jobid, stats);
 304         if (job == NULL)
 305                 RETURN(-ENOMEM);
 306
 307         job2 = cfs_hash_findadd_unique(stats->ojs_hash, job->js_jobid,
 308                                        &job->js_hash);
 309         if (job2 != job) {
 310                 job_putref(job);
 311                 job = job2;
 312                 /* We cannot LASSERT(!list_empty(&job->js_list)) here,
 313                  * since we just lost the race for inserting "job" into the
 314                  * ojs_list, and some other thread is doing it _right_now_.
 315                  * Instead, be content the other thread is doing this, since
 316                  * "job2" was initialized in job_alloc() already. LU-2163 */
 317         } else {
 318                 LASSERT(list_empty(&job->js_list));
 319                 write_lock(&stats->ojs_lock);
 320                 list_add_tail(&job->js_list, &stats->ojs_list);
 321                 write_unlock(&stats->ojs_lock);
 322         }
 323
 324 found:
 325         LASSERT(stats == job->js_jobstats);
 326         job->js_time_latest = ktime_get_real();
 327         lprocfs_counter_add(job->js_stats, event, amount);
 328
 329         job_putref(job);
 330
 331         RETURN(0);
 332 }
 333 EXPORT_SYMBOL(lprocfs_job_stats_log);
 334
 335 void lprocfs_job_stats_fini(struct obd_device *obd)
 336 {
 337         struct obd_job_stats *stats = &obd->u.obt.obt_jobstats;
 338
 339         if (stats->ojs_hash == NULL)
 340                 return;
 341
 342         lprocfs_job_cleanup(stats, true);
 343         cfs_hash_putref(stats->ojs_hash);
 344         stats->ojs_hash = NULL;
 345         LASSERT(list_empty(&stats->ojs_list));
 346 }
 347 EXPORT_SYMBOL(lprocfs_job_stats_fini);
 348
 349 static void *lprocfs_jobstats_seq_start(struct seq_file *p, loff_t *pos)
 350 {
 351         struct obd_job_stats *stats = p->private;
 352         loff_t off = *pos;
 353         struct job_stat *job;
 354
 355         read_lock(&stats->ojs_lock);
 356         if (off == 0)
 357                 return SEQ_START_TOKEN;
 358         off--;
 359         list_for_each_entry(job, &stats->ojs_list, js_list) {
 360                 if (!off--)
 361                         return job;
 362         }
 363         return NULL;
 364 }
 365
 366 static void lprocfs_jobstats_seq_stop(struct seq_file *p, void *v)
 367 {
 368         struct obd_job_stats *stats = p->private;
 369
 370         read_unlock(&stats->ojs_lock);
 371 }
 372
 373 static void *lprocfs_jobstats_seq_next(struct seq_file *p, void *v, loff_t *pos)
 374 {
 375         struct obd_job_stats *stats = p->private;
 376         struct job_stat *job;
 377         struct list_head *next;
 378
 379         ++*pos;
 380         if (v == SEQ_START_TOKEN) {
 381                 next = stats->ojs_list.next;
 382         } else {
 383                 job = (struct job_stat *)v;
 384                 next = job->js_list.next;
 385         }
 386
 387         return next == &stats->ojs_list ? NULL :
 388                 list_entry(next, struct job_stat, js_list);
 389 }
 390
 391 /*
 392  * Example of output on MDT:
 393  *
 394  * job_stats:
 395  * - job_id:        dd.4854
 396  *   snapshot_time: 1322494486.123456789
 397  *   start_time:    1322494476.012345678
 398  *   elapsed_time:  10.111111111
 399  *   open:          { samples:         1, unit: reqs }
 400  *   close:         { samples:         1, unit: reqs }
 401  *   mknod:         { samples:         0, unit: reqs }
 402  *   link:          { samples:         0, unit: reqs }
 403  *   unlink:        { samples:         0, unit: reqs }
 404  *   mkdir:         { samples:         0, unit: reqs }
 405  *   rmdir:         { samples:         0, unit: reqs }
 406  *   rename:        { samples:         0, unit: reqs }
 407  *   getattr:       { samples:         1, unit: reqs }
 408  *   setattr:       { samples:         0, unit: reqs }
 409  *   getxattr:      { samples:         0, unit: reqs }
 410  *   setxattr:      { samples:         0, unit: reqs }
 411  *   statfs:        { samples:         0, unit: reqs }
 412  *   sync:          { samples:         0, unit: reqs }
 413  *
 414  * Example of output on OST:
 415  *
 416  * job_stats:
 417  * - job_id         dd.4854
 418  *   snapshot_time: 1322494602.123456789
 419  *   start_time:    1322494592.987654321
 420  *   elapsed_time:  9.135802468
 421  *   read:          { samples: 0, unit: bytes, min:  0, max:  0, sum:  0 }
 422  *   write:         { samples: 1, unit: bytes, min: 4096, max: 4096, sum: 4096 }
 423  *   setattr:       { samples: 0, unit: reqs }
 424  *   punch:         { samples: 0, unit: reqs }
 425  *   sync:          { samples: 0, unit: reqs }
 426  */
 427
 428 static const char spaces[] = "                    ";
 429
 430 static int inline width(const char *str, int len)
 431 {
 432         return len - min((int)strlen(str), 15);
 433 }
 434
 435 static int lprocfs_jobstats_seq_show(struct seq_file *p, void *v)
 436 {
 437         struct job_stat *job = v;
 438         struct lprocfs_stats *s;
 439         struct lprocfs_counter ret;
 440         struct lprocfs_counter_header *cntr_header;
 441         char escaped[LUSTRE_JOBID_SIZE * 4] = "";
 442         char *quote = "", *c, *end;
 443         int i, joblen = 0;
 444
 445         if (v == SEQ_START_TOKEN) {
 446                 seq_printf(p, "job_stats:\n");
 447                 return 0;
 448         }
 449
 450         /* Quote and escape jobid characters to escape hex codes "\xHH" if
 451          * it contains any non-standard characters (space, newline, etc),
 452          * so it will be confined to single line and not break parsing.
 453          */
 454         for (c = job->js_jobid, end = job->js_jobid + sizeof(job->js_jobid);
 455              c < end && *c != '\0';
 456              c++, joblen++) {
 457                 if (!isalnum(*c) &&
 458                     *c != '.' && *c != '@' && *c != '-' && *c != '_') {
 459                         quote = "\"";
 460                         snprintf(escaped + joblen, sizeof(escaped), "\\x%02X",
 461                                  (unsigned char)*c);
 462                         joblen += 3;
 463                 } else {
 464                         escaped[joblen] = *c;
 465                 }
 466         }
 467
 468         seq_printf(p, "- %-16s %s%*s%s\n",
 469                    "job_id:", quote, joblen, escaped, quote);
 470         lprocfs_stats_header(p, job->js_time_latest, job->js_stats->ls_init,
 471                              16, ":", true, "  ");
 472
 473         s = job->js_stats;
 474         for (i = 0; i < s->ls_num; i++) {
 475                 cntr_header = &s->ls_cnt_header[i];
 476                 lprocfs_stats_collect(s, i, &ret);
 477
 478                 seq_printf(p, "  %s:%.*s { samples: %11llu",
 479                            cntr_header->lc_name,
 480                            width(cntr_header->lc_name, 15), spaces,
 481                            ret.lc_count);
 482                 if (cntr_header->lc_units[0] != '\0')
 483                         seq_printf(p, ", unit: %5s", cntr_header->lc_units);
 484
 485                 if (cntr_header->lc_config & LPROCFS_CNTR_AVGMINMAX) {
 486                         seq_printf(p, ", min: %8llu, max: %8llu, sum: %16llu",
 487                                    ret.lc_count ? ret.lc_min : 0,
 488                                    ret.lc_count ? ret.lc_max : 0,
 489                                    ret.lc_count ? ret.lc_sum : 0);
 490                 }
 491                 if (cntr_header->lc_config & LPROCFS_CNTR_STDDEV) {
 492                         seq_printf(p, ", sumsq: %18llu",
 493                                    ret.lc_count ? ret.lc_sumsquare : 0);
 494                 }
 495
 496                 seq_printf(p, " }\n");
 497
 498         }
 499
 500         return 0;
 501 }
 502
 503 static const struct seq_operations lprocfs_jobstats_seq_sops = {
 504         .start  = lprocfs_jobstats_seq_start,
 505         .stop   = lprocfs_jobstats_seq_stop,
 506         .next   = lprocfs_jobstats_seq_next,
 507         .show   = lprocfs_jobstats_seq_show,
 508 };
 509
 510 static int lprocfs_jobstats_seq_open(struct inode *inode, struct file *file)
 511 {
 512         struct seq_file *seq;
 513         int rc;
 514
 515         rc = seq_open(file, &lprocfs_jobstats_seq_sops);
 516         if (rc)
 517                 return rc;
 518         seq = file->private_data;
 519         seq->private = PDE_DATA(inode);
 520         return 0;
 521 }
 522
 523 static ssize_t lprocfs_jobstats_seq_write(struct file *file,
 524                                           const char __user *buf,
 525                                           size_t len, loff_t *off)
 526 {
 527         struct seq_file *seq = file->private_data;
 528         struct obd_job_stats *stats = seq->private;
 529         char jobid[LUSTRE_JOBID_SIZE];
 530         struct job_stat *job;
 531
 532         if (len == 0 || len >= LUSTRE_JOBID_SIZE)
 533                 return -EINVAL;
 534
 535         if (stats->ojs_hash == NULL)
 536                 return -ENODEV;
 537
 538         if (copy_from_user(jobid, buf, len))
 539                 return -EFAULT;
 540         jobid[len] = 0;
 541
 542         /* Trim '\n' if any */
 543         if (jobid[len - 1] == '\n')
 544                 jobid[len - 1] = 0;
 545
 546         if (strcmp(jobid, "clear") == 0) {
 547                 lprocfs_job_cleanup(stats, true);
 548
 549                 return len;
 550         }
 551
 552         if (strlen(jobid) == 0)
 553                 return -EINVAL;
 554
 555         job = cfs_hash_lookup(stats->ojs_hash, jobid);
 556         if (!job)
 557                 return -EINVAL;
 558
 559         cfs_hash_del_key(stats->ojs_hash, jobid);
 560
 561         job_putref(job);
 562         return len;
 563 }
 564
 565 /**
 566  * Clean up the seq file state when the /proc file is closed.
 567  *
 568  * This also expires old job stats from the cache after they have been
 569  * printed in case the system is idle and not generating new jobstats.
 570  *
 571  * \param[in] inode     struct inode for seq file being closed
 572  * \param[in] file      struct file for seq file being closed
 573  *
 574  * \retval              0 on success
 575  * \retval              negative errno on failure
 576  */
 577 static int lprocfs_jobstats_seq_release(struct inode *inode, struct file *file)
 578 {
 579         struct seq_file *seq = file->private_data;
 580         struct obd_job_stats *stats = seq->private;
 581
 582         lprocfs_job_cleanup(stats, false);
 583
 584         return lprocfs_seq_release(inode, file);
 585 }
 586
 587 static const struct proc_ops lprocfs_jobstats_seq_fops = {
 588         PROC_OWNER(THIS_MODULE)
 589         .proc_open      = lprocfs_jobstats_seq_open,
 590         .proc_read      = seq_read,
 591         .proc_write     = lprocfs_jobstats_seq_write,
 592         .proc_lseek     = seq_lseek,
 593         .proc_release   = lprocfs_jobstats_seq_release,
 594 };
 595
 596 int lprocfs_job_stats_init(struct obd_device *obd, int cntr_num,
 597                            cntr_init_callback init_fn)
 598 {
 599         struct proc_dir_entry *entry;
 600         struct obd_job_stats *stats;
 601         ENTRY;
 602
 603         LASSERT(obd->obd_proc_entry != NULL);
 604         LASSERT(obd->obd_type->typ_name);
 605
 606         if (cntr_num <= 0)
 607                 RETURN(-EINVAL);
 608
 609         if (init_fn == NULL)
 610                 RETURN(-EINVAL);
 611
 612         /* Currently needs to be a target due to the use of obt_jobstats. */
 613         if (strcmp(obd->obd_type->typ_name, LUSTRE_MDT_NAME) != 0 &&
 614             strcmp(obd->obd_type->typ_name, LUSTRE_OST_NAME) != 0) {
 615                 CERROR("%s: invalid device type %s for job stats: rc = %d\n",
 616                        obd->obd_name, obd->obd_type->typ_name, -EINVAL);
 617                 RETURN(-EINVAL);
 618         }
 619         stats = &obd->u.obt.obt_jobstats;
 620
 621         LASSERT(stats->ojs_hash == NULL);
 622         stats->ojs_hash = cfs_hash_create("JOB_STATS",
 623                                           HASH_JOB_STATS_CUR_BITS,
 624                                           HASH_JOB_STATS_MAX_BITS,
 625                                           HASH_JOB_STATS_BKT_BITS, 0,
 626                                           CFS_HASH_MIN_THETA,
 627                                           CFS_HASH_MAX_THETA,
 628                                           &job_stats_hash_ops,
 629                                           CFS_HASH_DEFAULT);
 630         if (stats->ojs_hash == NULL)
 631                 RETURN(-ENOMEM);
 632
 633         INIT_LIST_HEAD(&stats->ojs_list);
 634         rwlock_init(&stats->ojs_lock);
 635         stats->ojs_cntr_num = cntr_num;
 636         stats->ojs_cntr_init_fn = init_fn;
 637         /* Store 1/2 the actual interval, since we use that the most, and
 638          * it is easier to work with.
 639          */
 640         stats->ojs_cleanup_interval = ktime_set(600 / 2, 0); /* default 10 min*/
 641         stats->ojs_cleanup_last = ktime_get_real();
 642
 643         entry = lprocfs_add_simple(obd->obd_proc_entry, "job_stats", stats,
 644                                    &lprocfs_jobstats_seq_fops);
 645         if (IS_ERR(entry)) {
 646                 lprocfs_job_stats_fini(obd);
 647                 RETURN(-ENOMEM);
 648         }
 649         RETURN(0);
 650 }
 651 EXPORT_SYMBOL(lprocfs_job_stats_init);
 652 #endif /* CONFIG_PROC_FS*/
 653
 654 ssize_t job_cleanup_interval_show(struct kobject *kobj, struct attribute *attr,
 655                                   char *buf)
 656 {
 657         struct obd_device *obd = container_of(kobj, struct obd_device,
 658                                               obd_kset.kobj);
 659         struct obd_job_stats *stats;
 660         struct timespec64 ts;
 661
 662         stats = &obd->u.obt.obt_jobstats;
 663         ts = ktime_to_timespec64(stats->ojs_cleanup_interval);
 664
 665         return scnprintf(buf, PAGE_SIZE, "%lld\n", (long long)ts.tv_sec * 2);
 666 }
 667 EXPORT_SYMBOL(job_cleanup_interval_show);
 668
 669 ssize_t job_cleanup_interval_store(struct kobject *kobj,
 670                                    struct attribute *attr,
 671                                    const char *buffer, size_t count)
 672 {
 673         struct obd_device *obd = container_of(kobj, struct obd_device,
 674                                               obd_kset.kobj);
 675         struct obd_job_stats *stats;
 676         unsigned int val;
 677         int rc;
 678
 679         stats = &obd->u.obt.obt_jobstats;
 680
 681         rc = kstrtouint(buffer, 0, &val);
 682         if (rc)
 683                 return rc;
 684
 685         stats->ojs_cleanup_interval = ktime_set(val / 2, 0);
 686         lprocfs_job_cleanup(stats, false);
 687
 688         return count;
 689 }
 690 EXPORT_SYMBOL(job_cleanup_interval_store);