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();
 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();
 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_init = ktime_get();
 267         job->js_time_latest = job->js_time_init;
 268         job->js_jobstats = jobs;
 269         INIT_HLIST_NODE(&job->js_hash);
 270         INIT_LIST_HEAD(&job->js_list);
 271         atomic_set(&job->js_refcount, 1);
 272
 273         return job;
 274 }
 275
 276 int lprocfs_job_stats_log(struct obd_device *obd, char *jobid,
 277                           int event, long amount)
 278 {
 279         struct obd_job_stats *stats = &obd->u.obt.obt_jobstats;
 280         struct job_stat *job, *job2;
 281         ENTRY;
 282
 283         LASSERT(stats != NULL);
 284         LASSERT(stats->ojs_hash != NULL);
 285
 286         if (event >= stats->ojs_cntr_num)
 287                 RETURN(-EINVAL);
 288
 289         if (jobid == NULL || strlen(jobid) == 0)
 290                 RETURN(-EINVAL);
 291
 292         if (strlen(jobid) >= LUSTRE_JOBID_SIZE) {
 293                 CERROR("Invalid jobid size (%lu), expect(%d)\n",
 294                        (unsigned long)strlen(jobid) + 1, LUSTRE_JOBID_SIZE);
 295                 RETURN(-EINVAL);
 296         }
 297
 298         job = cfs_hash_lookup(stats->ojs_hash, jobid);
 299         if (job)
 300                 goto found;
 301
 302         lprocfs_job_cleanup(stats, false);
 303
 304         job = job_alloc(jobid, stats);
 305         if (job == NULL)
 306                 RETURN(-ENOMEM);
 307
 308         job2 = cfs_hash_findadd_unique(stats->ojs_hash, job->js_jobid,
 309                                        &job->js_hash);
 310         if (job2 != job) {
 311                 job_putref(job);
 312                 job = job2;
 313                 /* We cannot LASSERT(!list_empty(&job->js_list)) here,
 314                  * since we just lost the race for inserting "job" into the
 315                  * ojs_list, and some other thread is doing it _right_now_.
 316                  * Instead, be content the other thread is doing this, since
 317                  * "job2" was initialized in job_alloc() already. LU-2163 */
 318         } else {
 319                 LASSERT(list_empty(&job->js_list));
 320                 write_lock(&stats->ojs_lock);
 321                 list_add_tail(&job->js_list, &stats->ojs_list);
 322                 write_unlock(&stats->ojs_lock);
 323         }
 324
 325 found:
 326         LASSERT(stats == job->js_jobstats);
 327         job->js_time_latest = ktime_get();
 328         lprocfs_counter_add(job->js_stats, event, amount);
 329
 330         job_putref(job);
 331
 332         RETURN(0);
 333 }
 334 EXPORT_SYMBOL(lprocfs_job_stats_log);
 335
 336 void lprocfs_job_stats_fini(struct obd_device *obd)
 337 {
 338         struct obd_job_stats *stats = &obd->u.obt.obt_jobstats;
 339
 340         if (stats->ojs_hash == NULL)
 341                 return;
 342
 343         lprocfs_job_cleanup(stats, true);
 344         cfs_hash_putref(stats->ojs_hash);
 345         stats->ojs_hash = NULL;
 346         LASSERT(list_empty(&stats->ojs_list));
 347 }
 348 EXPORT_SYMBOL(lprocfs_job_stats_fini);
 349
 350 static void *lprocfs_jobstats_seq_start(struct seq_file *p, loff_t *pos)
 351 {
 352         struct obd_job_stats *stats = p->private;
 353         loff_t off = *pos;
 354         struct job_stat *job;
 355
 356         read_lock(&stats->ojs_lock);
 357         if (off == 0)
 358                 return SEQ_START_TOKEN;
 359         off--;
 360         list_for_each_entry(job, &stats->ojs_list, js_list) {
 361                 if (!off--)
 362                         return job;
 363         }
 364         return NULL;
 365 }
 366
 367 static void lprocfs_jobstats_seq_stop(struct seq_file *p, void *v)
 368 {
 369         struct obd_job_stats *stats = p->private;
 370
 371         read_unlock(&stats->ojs_lock);
 372 }
 373
 374 static void *lprocfs_jobstats_seq_next(struct seq_file *p, void *v, loff_t *pos)
 375 {
 376         struct obd_job_stats *stats = p->private;
 377         struct job_stat *job;
 378         struct list_head *next;
 379
 380         ++*pos;
 381         if (v == SEQ_START_TOKEN) {
 382                 next = stats->ojs_list.next;
 383         } else {
 384                 job = (struct job_stat *)v;
 385                 next = job->js_list.next;
 386         }
 387
 388         return next == &stats->ojs_list ? NULL :
 389                 list_entry(next, struct job_stat, js_list);
 390 }
 391
 392 /*
 393  * Example of output on MDT:
 394  *
 395  * job_stats:
 396  * - job_id:        dd.4854
 397  *   snapshot_time: 1322494486.123456789
 398  *   start_time:    1322494476.012345678
 399  *   elapsed_time:  10.111111111
 400  *   open:          { samples:         1, unit: reqs }
 401  *   close:         { samples:         1, unit: reqs }
 402  *   mknod:         { samples:         0, unit: reqs }
 403  *   link:          { samples:         0, unit: reqs }
 404  *   unlink:        { samples:         0, unit: reqs }
 405  *   mkdir:         { samples:         0, unit: reqs }
 406  *   rmdir:         { samples:         0, unit: reqs }
 407  *   rename:        { samples:         0, unit: reqs }
 408  *   getattr:       { samples:         1, unit: reqs }
 409  *   setattr:       { samples:         0, unit: reqs }
 410  *   getxattr:      { samples:         0, unit: reqs }
 411  *   setxattr:      { samples:         0, unit: reqs }
 412  *   statfs:        { samples:         0, unit: reqs }
 413  *   sync:          { samples:         0, unit: reqs }
 414  *
 415  * Example of output on OST:
 416  *
 417  * job_stats:
 418  * - job_id         dd.4854
 419  *   snapshot_time: 1322494602.123456789
 420  *   start_time:    1322494592.987654321
 421  *   elapsed_time:  9.135802468
 422  *   read:          { samples: 0, unit: bytes, min:  0, max:  0, sum:  0 }
 423  *   write:         { samples: 1, unit: bytes, min: 4096, max: 4096, sum: 4096 }
 424  *   setattr:       { samples: 0, unit: reqs }
 425  *   punch:         { samples: 0, unit: reqs }
 426  *   sync:          { samples: 0, unit: reqs }
 427  */
 428
 429 static const char spaces[] = "                    ";
 430
 431 static int inline width(const char *str, int len)
 432 {
 433         return len - min((int)strlen(str), 15);
 434 }
 435
 436 static int lprocfs_jobstats_seq_show(struct seq_file *p, void *v)
 437 {
 438         struct job_stat *job = v;
 439         struct lprocfs_stats *s;
 440         struct lprocfs_counter ret;
 441         struct lprocfs_counter_header *cntr_header;
 442         int i;
 443
 444         if (v == SEQ_START_TOKEN) {
 445                 seq_printf(p, "job_stats:\n");
 446                 return 0;
 447         }
 448
 449         /* Replace the non-printable character in jobid with '?', so
 450          * that the output of jobid will be confined in single line. */
 451         seq_printf(p, "- %-16s ", "job_id:");
 452         for (i = 0; i < strlen(job->js_jobid); i++) {
 453                 if (isprint(job->js_jobid[i]) != 0)
 454                         seq_putc(p, job->js_jobid[i]);
 455                 else
 456                         seq_putc(p, '?');
 457         }
 458         seq_putc(p, '\n');
 459
 460         lprocfs_stats_header(p, job->js_time_latest, job->js_time_init, 16,
 461                              ":", true);
 462
 463         s = job->js_stats;
 464         for (i = 0; i < s->ls_num; i++) {
 465                 cntr_header = &s->ls_cnt_header[i];
 466                 lprocfs_stats_collect(s, i, &ret);
 467
 468                 seq_printf(p, "  %s:%.*s { samples: %11llu",
 469                            cntr_header->lc_name,
 470                            width(cntr_header->lc_name, 15), spaces,
 471                            ret.lc_count);
 472                 if (cntr_header->lc_units[0] != '\0')
 473                         seq_printf(p, ", unit: %5s", cntr_header->lc_units);
 474
 475                 if (cntr_header->lc_config & LPROCFS_CNTR_AVGMINMAX) {
 476                         seq_printf(p, ", min: %8llu, max: %8llu, sum: %16llu",
 477                                    ret.lc_count ? ret.lc_min : 0,
 478                                    ret.lc_count ? ret.lc_max : 0,
 479                                    ret.lc_count ? ret.lc_sum : 0);
 480                 }
 481                 if (cntr_header->lc_config & LPROCFS_CNTR_STDDEV) {
 482                         seq_printf(p, ", sumsq: %18llu",
 483                                    ret.lc_count ? ret.lc_sumsquare : 0);
 484                 }
 485
 486                 seq_printf(p, " }\n");
 487
 488         }
 489         return 0;
 490 }
 491
 492 static const struct seq_operations lprocfs_jobstats_seq_sops = {
 493         .start  = lprocfs_jobstats_seq_start,
 494         .stop   = lprocfs_jobstats_seq_stop,
 495         .next   = lprocfs_jobstats_seq_next,
 496         .show   = lprocfs_jobstats_seq_show,
 497 };
 498
 499 static int lprocfs_jobstats_seq_open(struct inode *inode, struct file *file)
 500 {
 501         struct seq_file *seq;
 502         int rc;
 503
 504         rc = seq_open(file, &lprocfs_jobstats_seq_sops);
 505         if (rc)
 506                 return rc;
 507         seq = file->private_data;
 508         seq->private = PDE_DATA(inode);
 509         return 0;
 510 }
 511
 512 static ssize_t lprocfs_jobstats_seq_write(struct file *file,
 513                                           const char __user *buf,
 514                                           size_t len, loff_t *off)
 515 {
 516         struct seq_file *seq = file->private_data;
 517         struct obd_job_stats *stats = seq->private;
 518         char jobid[LUSTRE_JOBID_SIZE];
 519         struct job_stat *job;
 520
 521         if (len == 0 || len >= LUSTRE_JOBID_SIZE)
 522                 return -EINVAL;
 523
 524         if (stats->ojs_hash == NULL)
 525                 return -ENODEV;
 526
 527         if (copy_from_user(jobid, buf, len))
 528                 return -EFAULT;
 529         jobid[len] = 0;
 530
 531         /* Trim '\n' if any */
 532         if (jobid[len - 1] == '\n')
 533                 jobid[len - 1] = 0;
 534
 535         if (strcmp(jobid, "clear") == 0) {
 536                 lprocfs_job_cleanup(stats, true);
 537
 538                 return len;
 539         }
 540
 541         if (strlen(jobid) == 0)
 542                 return -EINVAL;
 543
 544         job = cfs_hash_lookup(stats->ojs_hash, jobid);
 545         if (!job)
 546                 return -EINVAL;
 547
 548         cfs_hash_del_key(stats->ojs_hash, jobid);
 549
 550         job_putref(job);
 551         return len;
 552 }
 553
 554 /**
 555  * Clean up the seq file state when the /proc file is closed.
 556  *
 557  * This also expires old job stats from the cache after they have been
 558  * printed in case the system is idle and not generating new jobstats.
 559  *
 560  * \param[in] inode     struct inode for seq file being closed
 561  * \param[in] file      struct file for seq file being closed
 562  *
 563  * \retval              0 on success
 564  * \retval              negative errno on failure
 565  */
 566 static int lprocfs_jobstats_seq_release(struct inode *inode, struct file *file)
 567 {
 568         struct seq_file *seq = file->private_data;
 569         struct obd_job_stats *stats = seq->private;
 570
 571         lprocfs_job_cleanup(stats, false);
 572
 573         return lprocfs_seq_release(inode, file);
 574 }
 575
 576 static const struct proc_ops lprocfs_jobstats_seq_fops = {
 577         PROC_OWNER(THIS_MODULE)
 578         .proc_open      = lprocfs_jobstats_seq_open,
 579         .proc_read      = seq_read,
 580         .proc_write     = lprocfs_jobstats_seq_write,
 581         .proc_lseek     = seq_lseek,
 582         .proc_release   = lprocfs_jobstats_seq_release,
 583 };
 584
 585 int lprocfs_job_stats_init(struct obd_device *obd, int cntr_num,
 586                            cntr_init_callback init_fn)
 587 {
 588         struct proc_dir_entry *entry;
 589         struct obd_job_stats *stats;
 590         ENTRY;
 591
 592         LASSERT(obd->obd_proc_entry != NULL);
 593         LASSERT(obd->obd_type->typ_name);
 594
 595         if (cntr_num <= 0)
 596                 RETURN(-EINVAL);
 597
 598         if (init_fn == NULL)
 599                 RETURN(-EINVAL);
 600
 601         /* Currently needs to be a target due to the use of obt_jobstats. */
 602         if (strcmp(obd->obd_type->typ_name, LUSTRE_MDT_NAME) != 0 &&
 603             strcmp(obd->obd_type->typ_name, LUSTRE_OST_NAME) != 0) {
 604                 CERROR("%s: invalid device type %s for job stats: rc = %d\n",
 605                        obd->obd_name, obd->obd_type->typ_name, -EINVAL);
 606                 RETURN(-EINVAL);
 607         }
 608         stats = &obd->u.obt.obt_jobstats;
 609
 610         LASSERT(stats->ojs_hash == NULL);
 611         stats->ojs_hash = cfs_hash_create("JOB_STATS",
 612                                           HASH_JOB_STATS_CUR_BITS,
 613                                           HASH_JOB_STATS_MAX_BITS,
 614                                           HASH_JOB_STATS_BKT_BITS, 0,
 615                                           CFS_HASH_MIN_THETA,
 616                                           CFS_HASH_MAX_THETA,
 617                                           &job_stats_hash_ops,
 618                                           CFS_HASH_DEFAULT);
 619         if (stats->ojs_hash == NULL)
 620                 RETURN(-ENOMEM);
 621
 622         INIT_LIST_HEAD(&stats->ojs_list);
 623         rwlock_init(&stats->ojs_lock);
 624         stats->ojs_cntr_num = cntr_num;
 625         stats->ojs_cntr_init_fn = init_fn;
 626         /* Store 1/2 the actual interval, since we use that the most, and
 627          * it is easier to work with.
 628          */
 629         stats->ojs_cleanup_interval = ktime_set(600 / 2, 0); /* default 10 min*/
 630         stats->ojs_cleanup_last = ktime_get();
 631
 632         entry = lprocfs_add_simple(obd->obd_proc_entry, "job_stats", stats,
 633                                    &lprocfs_jobstats_seq_fops);
 634         if (IS_ERR(entry)) {
 635                 lprocfs_job_stats_fini(obd);
 636                 RETURN(-ENOMEM);
 637         }
 638         RETURN(0);
 639 }
 640 EXPORT_SYMBOL(lprocfs_job_stats_init);
 641 #endif /* CONFIG_PROC_FS*/
 642
 643 ssize_t job_cleanup_interval_show(struct kobject *kobj, struct attribute *attr,
 644                                   char *buf)
 645 {
 646         struct obd_device *obd = container_of(kobj, struct obd_device,
 647                                               obd_kset.kobj);
 648         struct obd_job_stats *stats;
 649         struct timespec64 ts;
 650
 651         stats = &obd->u.obt.obt_jobstats;
 652         ts = ktime_to_timespec64(stats->ojs_cleanup_interval);
 653
 654         return scnprintf(buf, PAGE_SIZE, "%lld\n", (long long)ts.tv_sec * 2);
 655 }
 656 EXPORT_SYMBOL(job_cleanup_interval_show);
 657
 658 ssize_t job_cleanup_interval_store(struct kobject *kobj,
 659                                    struct attribute *attr,
 660                                    const char *buffer, size_t count)
 661 {
 662         struct obd_device *obd = container_of(kobj, struct obd_device,
 663                                               obd_kset.kobj);
 664         struct obd_job_stats *stats;
 665         unsigned int val;
 666         int rc;
 667
 668         stats = &obd->u.obt.obt_jobstats;
 669
 670         rc = kstrtouint(buffer, 0, &val);
 671         if (rc)
 672                 return rc;
 673
 674         stats->ojs_cleanup_interval = ktime_set(val / 2, 0);
 675         lprocfs_job_cleanup(stats, false);
 676
 677         return count;
 678 }
 679 EXPORT_SYMBOL(job_cleanup_interval_store);