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         time64_t                js_timestamp;   /* seconds of most recent stat*/
  70         struct lprocfs_stats    *js_stats;      /* per-job statistics */
  71         struct obd_job_stats    *js_jobstats;   /* for accessing ojs_lock */
  72 };
  73
  74 static unsigned
  75 job_stat_hash(struct cfs_hash *hs, const void *key, unsigned mask)
  76 {
  77         return cfs_hash_djb2_hash(key, strlen(key), mask);
  78 }
  79
  80 static void *job_stat_key(struct hlist_node *hnode)
  81 {
  82         struct job_stat *job;
  83         job = hlist_entry(hnode, struct job_stat, js_hash);
  84         return job->js_jobid;
  85 }
  86
  87 static int job_stat_keycmp(const void *key, struct hlist_node *hnode)
  88 {
  89         struct job_stat *job;
  90         job = hlist_entry(hnode, struct job_stat, js_hash);
  91         return (strlen(job->js_jobid) == strlen(key)) &&
  92                !strncmp(job->js_jobid, key, strlen(key));
  93 }
  94
  95 static void *job_stat_object(struct hlist_node *hnode)
  96 {
  97         return hlist_entry(hnode, struct job_stat, js_hash);
  98 }
  99
 100 static void job_stat_get(struct cfs_hash *hs, struct hlist_node *hnode)
 101 {
 102         struct job_stat *job;
 103         job = hlist_entry(hnode, struct job_stat, js_hash);
 104         atomic_inc(&job->js_refcount);
 105 }
 106
 107 static void job_free(struct job_stat *job)
 108 {
 109         LASSERT(atomic_read(&job->js_refcount) == 0);
 110         LASSERT(job->js_jobstats != NULL);
 111
 112         write_lock(&job->js_jobstats->ojs_lock);
 113         list_del_init(&job->js_list);
 114         write_unlock(&job->js_jobstats->ojs_lock);
 115
 116         lprocfs_free_stats(&job->js_stats);
 117         OBD_FREE_PTR(job);
 118 }
 119
 120 static void job_putref(struct job_stat *job)
 121 {
 122         LASSERT(atomic_read(&job->js_refcount) > 0);
 123         if (atomic_dec_and_test(&job->js_refcount))
 124                 job_free(job);
 125 }
 126
 127 static void job_stat_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
 128 {
 129         struct job_stat *job;
 130         job = hlist_entry(hnode, struct job_stat, js_hash);
 131         job_putref(job);
 132 }
 133
 134 static void job_stat_exit(struct cfs_hash *hs, struct hlist_node *hnode)
 135 {
 136         CERROR("should not have any items\n");
 137 }
 138
 139 static struct cfs_hash_ops job_stats_hash_ops = {
 140         .hs_hash       = job_stat_hash,
 141         .hs_key        = job_stat_key,
 142         .hs_keycmp     = job_stat_keycmp,
 143         .hs_object     = job_stat_object,
 144         .hs_get        = job_stat_get,
 145         .hs_put_locked = job_stat_put_locked,
 146         .hs_exit       = job_stat_exit,
 147 };
 148
 149 /**
 150  * Jobstats expiry iterator to clean up old jobids
 151  *
 152  * Called for each job_stat structure on this device, it should delete stats
 153  * older than the specified \a oldest_time in seconds.  If \a oldest_time is
 154  * in the future then this will delete all statistics (e.g. during shutdown).
 155  *
 156  * \param[in] hs        hash of all jobids on this device
 157  * \param[in] bd        hash bucket containing this jobid
 158  * \param[in] hnode     hash structure for this jobid
 159  * \param[in] data      pointer to stats expiry time in seconds
 160  */
 161 static int job_cleanup_iter_callback(struct cfs_hash *hs,
 162                                      struct cfs_hash_bd *bd,
 163                                      struct hlist_node *hnode, void *data)
 164 {
 165         time64_t oldest_time = *((time64_t *)data);
 166         struct job_stat *job;
 167
 168         job = hlist_entry(hnode, struct job_stat, js_hash);
 169         if (job->js_timestamp < oldest_time)
 170                 cfs_hash_bd_del_locked(hs, bd, hnode);
 171
 172         return 0;
 173 }
 174
 175 /**
 176  * Clean up jobstats that were updated more than \a before seconds ago.
 177  *
 178  * Since this function may be called frequently, do not scan all of the
 179  * jobstats on each call, only twice per cleanup interval.  That means stats
 180  * may be around on average cleanup_interval / 4 longer than necessary,
 181  * but that is not considered harmful.
 182  *
 183  * If \a before is negative then this will force clean up all jobstats due
 184  * to the expiry time being in the future (e.g. at shutdown).
 185  *
 186  * If there is already another thread doing jobstats cleanup, don't try to
 187  * do this again in the current thread unless this is a force cleanup.
 188  *
 189  * \param[in] stats     stucture tracking all job stats for this device
 190  * \param[in] before    expire jobstats updated more than this many seconds ago
 191  */
 192 static void lprocfs_job_cleanup(struct obd_job_stats *stats, int before)
 193 {
 194         time64_t now = ktime_get_real_seconds();
 195         time64_t oldest;
 196
 197         if (likely(before >= 0)) {
 198                 unsigned int cleanup_interval = stats->ojs_cleanup_interval;
 199
 200                 if (cleanup_interval == 0 || before == 0)
 201                         return;
 202
 203                 if (now < stats->ojs_last_cleanup + cleanup_interval / 2)
 204                         return;
 205
 206                 if (stats->ojs_cleaning)
 207                         return;
 208         }
 209
 210         write_lock(&stats->ojs_lock);
 211         if (before >= 0 && stats->ojs_cleaning) {
 212                 write_unlock(&stats->ojs_lock);
 213                 return;
 214         }
 215
 216         stats->ojs_cleaning = true;
 217         write_unlock(&stats->ojs_lock);
 218
 219         /* Can't hold ojs_lock over hash iteration, since it is grabbed by
 220          * job_cleanup_iter_callback()
 221          *   ->cfs_hash_bd_del_locked()
 222          *     ->job_putref()
 223          *       ->job_free()
 224          *
 225          * Holding ojs_lock isn't necessary for safety of the hash iteration,
 226          * since locking of the hash is handled internally, but there isn't
 227          * any benefit to having multiple threads doing cleanup at one time.
 228          */
 229         oldest = now - before;
 230         cfs_hash_for_each_safe(stats->ojs_hash, job_cleanup_iter_callback,
 231                                &oldest);
 232
 233         write_lock(&stats->ojs_lock);
 234         stats->ojs_cleaning = false;
 235         stats->ojs_last_cleanup = ktime_get_real_seconds();
 236         write_unlock(&stats->ojs_lock);
 237 }
 238
 239 static struct job_stat *job_alloc(char *jobid, struct obd_job_stats *jobs)
 240 {
 241         struct job_stat *job;
 242
 243         OBD_ALLOC_PTR(job);
 244         if (job == NULL)
 245                 return NULL;
 246
 247         job->js_stats = lprocfs_alloc_stats(jobs->ojs_cntr_num, 0);
 248         if (job->js_stats == NULL) {
 249                 OBD_FREE_PTR(job);
 250                 return NULL;
 251         }
 252
 253         jobs->ojs_cntr_init_fn(job->js_stats);
 254
 255         memcpy(job->js_jobid, jobid, sizeof(job->js_jobid));
 256         job->js_timestamp = ktime_get_real_seconds();
 257         job->js_jobstats = jobs;
 258         INIT_HLIST_NODE(&job->js_hash);
 259         INIT_LIST_HEAD(&job->js_list);
 260         atomic_set(&job->js_refcount, 1);
 261
 262         return job;
 263 }
 264
 265 int lprocfs_job_stats_log(struct obd_device *obd, char *jobid,
 266                           int event, long amount)
 267 {
 268         struct obd_job_stats *stats = &obd->u.obt.obt_jobstats;
 269         struct job_stat *job, *job2;
 270         ENTRY;
 271
 272         LASSERT(stats != NULL);
 273         LASSERT(stats->ojs_hash != NULL);
 274
 275         if (event >= stats->ojs_cntr_num)
 276                 RETURN(-EINVAL);
 277
 278         if (jobid == NULL || strlen(jobid) == 0)
 279                 RETURN(-EINVAL);
 280
 281         if (strlen(jobid) >= LUSTRE_JOBID_SIZE) {
 282                 CERROR("Invalid jobid size (%lu), expect(%d)\n",
 283                        (unsigned long)strlen(jobid) + 1, LUSTRE_JOBID_SIZE);
 284                 RETURN(-EINVAL);
 285         }
 286
 287         job = cfs_hash_lookup(stats->ojs_hash, jobid);
 288         if (job)
 289                 goto found;
 290
 291         lprocfs_job_cleanup(stats, stats->ojs_cleanup_interval);
 292
 293         job = job_alloc(jobid, stats);
 294         if (job == NULL)
 295                 RETURN(-ENOMEM);
 296
 297         job2 = cfs_hash_findadd_unique(stats->ojs_hash, job->js_jobid,
 298                                        &job->js_hash);
 299         if (job2 != job) {
 300                 job_putref(job);
 301                 job = job2;
 302                 /* We cannot LASSERT(!list_empty(&job->js_list)) here,
 303                  * since we just lost the race for inserting "job" into the
 304                  * ojs_list, and some other thread is doing it _right_now_.
 305                  * Instead, be content the other thread is doing this, since
 306                  * "job2" was initialized in job_alloc() already. LU-2163 */
 307         } else {
 308                 LASSERT(list_empty(&job->js_list));
 309                 write_lock(&stats->ojs_lock);
 310                 list_add_tail(&job->js_list, &stats->ojs_list);
 311                 write_unlock(&stats->ojs_lock);
 312         }
 313
 314 found:
 315         LASSERT(stats == job->js_jobstats);
 316         job->js_timestamp = ktime_get_real_seconds();
 317         lprocfs_counter_add(job->js_stats, event, amount);
 318
 319         job_putref(job);
 320
 321         RETURN(0);
 322 }
 323 EXPORT_SYMBOL(lprocfs_job_stats_log);
 324
 325 void lprocfs_job_stats_fini(struct obd_device *obd)
 326 {
 327         struct obd_job_stats *stats = &obd->u.obt.obt_jobstats;
 328
 329         if (stats->ojs_hash == NULL)
 330                 return;
 331
 332         lprocfs_job_cleanup(stats, -99);
 333         cfs_hash_putref(stats->ojs_hash);
 334         stats->ojs_hash = NULL;
 335         LASSERT(list_empty(&stats->ojs_list));
 336 }
 337 EXPORT_SYMBOL(lprocfs_job_stats_fini);
 338
 339 static void *lprocfs_jobstats_seq_start(struct seq_file *p, loff_t *pos)
 340 {
 341         struct obd_job_stats *stats = p->private;
 342         loff_t off = *pos;
 343         struct job_stat *job;
 344
 345         read_lock(&stats->ojs_lock);
 346         if (off == 0)
 347                 return SEQ_START_TOKEN;
 348         off--;
 349         list_for_each_entry(job, &stats->ojs_list, js_list) {
 350                 if (!off--)
 351                         return job;
 352         }
 353         return NULL;
 354 }
 355
 356 static void lprocfs_jobstats_seq_stop(struct seq_file *p, void *v)
 357 {
 358         struct obd_job_stats *stats = p->private;
 359
 360         read_unlock(&stats->ojs_lock);
 361 }
 362
 363 static void *lprocfs_jobstats_seq_next(struct seq_file *p, void *v, loff_t *pos)
 364 {
 365         struct obd_job_stats *stats = p->private;
 366         struct job_stat *job;
 367         struct list_head *next;
 368
 369         ++*pos;
 370         if (v == SEQ_START_TOKEN) {
 371                 next = stats->ojs_list.next;
 372         } else {
 373                 job = (struct job_stat *)v;
 374                 next = job->js_list.next;
 375         }
 376
 377         return next == &stats->ojs_list ? NULL :
 378                 list_entry(next, struct job_stat, js_list);
 379 }
 380
 381 /*
 382  * Example of output on MDT:
 383  *
 384  * job_stats:
 385  * - job_id:        dd.4854
 386  *   snapshot_time: 1322494486
 387  *   open:          { samples:         1, unit: reqs }
 388  *   close:         { samples:         1, unit: reqs }
 389  *   mknod:         { samples:         0, unit: reqs }
 390  *   link:          { samples:         0, unit: reqs }
 391  *   unlink:        { samples:         0, unit: reqs }
 392  *   mkdir:         { samples:         0, unit: reqs }
 393  *   rmdir:         { samples:         0, unit: reqs }
 394  *   rename:        { samples:         0, unit: reqs }
 395  *   getattr:       { samples:         1, unit: reqs }
 396  *   setattr:       { samples:         0, unit: reqs }
 397  *   getxattr:      { samples:         0, unit: reqs }
 398  *   setxattr:      { samples:         0, unit: reqs }
 399  *   statfs:        { samples:         0, unit: reqs }
 400  *   sync:          { samples:         0, unit: reqs }
 401  *
 402  * Example of output on OST:
 403  *
 404  * job_stats:
 405  * - job_id         dd.4854
 406  *   snapshot_time: 1322494602
 407  *   read:          { samples: 0, unit: bytes, min:  0, max:  0, sum:  0 }
 408  *   write:         { samples: 1, unit: bytes, min: 4096, max: 4096, sum: 4096 }
 409  *   setattr:       { samples: 0, unit: reqs }
 410  *   punch:         { samples: 0, unit: reqs }
 411  *   sync:          { samples: 0, unit: reqs }
 412  */
 413
 414 static const char spaces[] = "                    ";
 415
 416 static int inline width(const char *str, int len)
 417 {
 418         return len - min((int)strlen(str), 15);
 419 }
 420
 421 static int lprocfs_jobstats_seq_show(struct seq_file *p, void *v)
 422 {
 423         struct job_stat                 *job = v;
 424         struct lprocfs_stats            *s;
 425         struct lprocfs_counter          ret;
 426         struct lprocfs_counter_header   *cntr_header;
 427         int                             i;
 428
 429         if (v == SEQ_START_TOKEN) {
 430                 seq_printf(p, "job_stats:\n");
 431                 return 0;
 432         }
 433
 434         /* Replace the non-printable character in jobid with '?', so
 435          * that the output of jobid will be confined in single line. */
 436         seq_printf(p, "- %-16s ", "job_id:");
 437         for (i = 0; i < strlen(job->js_jobid); i++) {
 438                 if (isprint(job->js_jobid[i]) != 0)
 439                         seq_putc(p, job->js_jobid[i]);
 440                 else
 441                         seq_putc(p, '?');
 442         }
 443         seq_putc(p, '\n');
 444
 445         seq_printf(p, "  %-16s %lld\n", "snapshot_time:", job->js_timestamp);
 446
 447         s = job->js_stats;
 448         for (i = 0; i < s->ls_num; i++) {
 449                 cntr_header = &s->ls_cnt_header[i];
 450                 lprocfs_stats_collect(s, i, &ret);
 451
 452                 seq_printf(p, "  %s:%.*s { samples: %11llu",
 453                            cntr_header->lc_name,
 454                            width(cntr_header->lc_name, 15), spaces,
 455                            ret.lc_count);
 456                 if (cntr_header->lc_units[0] != '\0')
 457                         seq_printf(p, ", unit: %5s", cntr_header->lc_units);
 458
 459                 if (cntr_header->lc_config & LPROCFS_CNTR_AVGMINMAX) {
 460                         seq_printf(p, ", min:%8llu, max:%8llu,"
 461                                    " sum:%16llu",
 462                                    ret.lc_count ? ret.lc_min : 0,
 463                                    ret.lc_count ? ret.lc_max : 0,
 464                                    ret.lc_count ? ret.lc_sum : 0);
 465                 }
 466                 if (cntr_header->lc_config & LPROCFS_CNTR_STDDEV) {
 467                         seq_printf(p, ", sumsq: %18llu",
 468                                    ret.lc_count ? ret.lc_sumsquare : 0);
 469                 }
 470
 471                 seq_printf(p, " }\n");
 472
 473         }
 474         return 0;
 475 }
 476
 477 static const struct seq_operations lprocfs_jobstats_seq_sops = {
 478         .start  = lprocfs_jobstats_seq_start,
 479         .stop   = lprocfs_jobstats_seq_stop,
 480         .next   = lprocfs_jobstats_seq_next,
 481         .show   = lprocfs_jobstats_seq_show,
 482 };
 483
 484 static int lprocfs_jobstats_seq_open(struct inode *inode, struct file *file)
 485 {
 486         struct seq_file *seq;
 487         int rc;
 488
 489         rc = LPROCFS_ENTRY_CHECK(inode);
 490         if (rc < 0)
 491                 return rc;
 492
 493         rc = seq_open(file, &lprocfs_jobstats_seq_sops);
 494         if (rc)
 495                 return rc;
 496         seq = file->private_data;
 497         seq->private = PDE_DATA(inode);
 498         return 0;
 499 }
 500
 501 static ssize_t lprocfs_jobstats_seq_write(struct file *file,
 502                                           const char __user *buf,
 503                                           size_t len, loff_t *off)
 504 {
 505         struct seq_file *seq = file->private_data;
 506         struct obd_job_stats *stats = seq->private;
 507         char jobid[LUSTRE_JOBID_SIZE];
 508         struct job_stat *job;
 509
 510         if (len == 0 || len >= LUSTRE_JOBID_SIZE)
 511                 return -EINVAL;
 512
 513         if (stats->ojs_hash == NULL)
 514                 return -ENODEV;
 515
 516         if (copy_from_user(jobid, buf, len))
 517                 return -EFAULT;
 518         jobid[len] = 0;
 519
 520         /* Trim '\n' if any */
 521         if (jobid[len - 1] == '\n')
 522                 jobid[len - 1] = 0;
 523
 524         if (strcmp(jobid, "clear") == 0) {
 525                 lprocfs_job_cleanup(stats, -99);
 526
 527                 return len;
 528         }
 529
 530         if (strlen(jobid) == 0)
 531                 return -EINVAL;
 532
 533         job = cfs_hash_lookup(stats->ojs_hash, jobid);
 534         if (!job)
 535                 return -EINVAL;
 536
 537         cfs_hash_del_key(stats->ojs_hash, jobid);
 538
 539         job_putref(job);
 540         return len;
 541 }
 542
 543 /**
 544  * Clean up the seq file state when the /proc file is closed.
 545  *
 546  * This also expires old job stats from the cache after they have been
 547  * printed in case the system is idle and not generating new jobstats.
 548  *
 549  * \param[in] inode     struct inode for seq file being closed
 550  * \param[in] file      struct file for seq file being closed
 551  *
 552  * \retval              0 on success
 553  * \retval              negative errno on failure
 554  */
 555 static int lprocfs_jobstats_seq_release(struct inode *inode, struct file *file)
 556 {
 557         struct seq_file *seq = file->private_data;
 558         struct obd_job_stats *stats = seq->private;
 559
 560         lprocfs_job_cleanup(stats, stats->ojs_cleanup_interval);
 561
 562         return lprocfs_seq_release(inode, file);
 563 }
 564
 565 static const struct file_operations lprocfs_jobstats_seq_fops = {
 566         .owner   = THIS_MODULE,
 567         .open    = lprocfs_jobstats_seq_open,
 568         .read    = seq_read,
 569         .write   = lprocfs_jobstats_seq_write,
 570         .llseek  = seq_lseek,
 571         .release = lprocfs_jobstats_seq_release,
 572 };
 573
 574 int lprocfs_job_stats_init(struct obd_device *obd, int cntr_num,
 575                            cntr_init_callback init_fn)
 576 {
 577         struct proc_dir_entry *entry;
 578         struct obd_job_stats *stats;
 579         ENTRY;
 580
 581         LASSERT(obd->obd_proc_entry != NULL);
 582         LASSERT(obd->obd_type->typ_name);
 583
 584         if (cntr_num <= 0)
 585                 RETURN(-EINVAL);
 586
 587         if (init_fn == NULL)
 588                 RETURN(-EINVAL);
 589
 590         /* Currently needs to be a target due to the use of obt_jobstats. */
 591         if (strcmp(obd->obd_type->typ_name, LUSTRE_MDT_NAME) != 0 &&
 592             strcmp(obd->obd_type->typ_name, LUSTRE_OST_NAME) != 0) {
 593                 CERROR("%s: invalid device type %s for job stats: rc = %d\n",
 594                        obd->obd_name, obd->obd_type->typ_name, -EINVAL);
 595                 RETURN(-EINVAL);
 596         }
 597         stats = &obd->u.obt.obt_jobstats;
 598
 599         LASSERT(stats->ojs_hash == NULL);
 600         stats->ojs_hash = cfs_hash_create("JOB_STATS",
 601                                           HASH_JOB_STATS_CUR_BITS,
 602                                           HASH_JOB_STATS_MAX_BITS,
 603                                           HASH_JOB_STATS_BKT_BITS, 0,
 604                                           CFS_HASH_MIN_THETA,
 605                                           CFS_HASH_MAX_THETA,
 606                                           &job_stats_hash_ops,
 607                                           CFS_HASH_DEFAULT);
 608         if (stats->ojs_hash == NULL)
 609                 RETURN(-ENOMEM);
 610
 611         INIT_LIST_HEAD(&stats->ojs_list);
 612         rwlock_init(&stats->ojs_lock);
 613         stats->ojs_cntr_num = cntr_num;
 614         stats->ojs_cntr_init_fn = init_fn;
 615         stats->ojs_cleanup_interval = 600; /* 10 mins by default */
 616         stats->ojs_last_cleanup = ktime_get_real_seconds();
 617
 618         entry = lprocfs_add_simple(obd->obd_proc_entry, "job_stats", stats,
 619                                    &lprocfs_jobstats_seq_fops);
 620         if (IS_ERR(entry)) {
 621                 lprocfs_job_stats_fini(obd);
 622                 RETURN(-ENOMEM);
 623         }
 624         RETURN(0);
 625 }
 626 EXPORT_SYMBOL(lprocfs_job_stats_init);
 627
 628 int lprocfs_job_interval_seq_show(struct seq_file *m, void *data)
 629 {
 630         struct obd_device *obd = m->private;
 631         struct obd_job_stats *stats;
 632
 633         if (obd == NULL)
 634                 return -ENODEV;
 635
 636         stats = &obd->u.obt.obt_jobstats;
 637         seq_printf(m, "%d\n", stats->ojs_cleanup_interval);
 638         return 0;
 639 }
 640 EXPORT_SYMBOL(lprocfs_job_interval_seq_show);
 641
 642 ssize_t
 643 lprocfs_job_interval_seq_write(struct file *file, const char __user *buffer,
 644                                 size_t count, loff_t *off)
 645 {
 646         struct obd_device *obd;
 647         struct obd_job_stats *stats;
 648         unsigned int val;
 649         int rc;
 650
 651         obd = ((struct seq_file *)file->private_data)->private;
 652         if (obd == NULL)
 653                 return -ENODEV;
 654
 655         stats = &obd->u.obt.obt_jobstats;
 656
 657         rc = kstrtouint_from_user(buffer, count, 0, &val);
 658         if (rc)
 659                 return rc;
 660
 661         stats->ojs_cleanup_interval = val;
 662         lprocfs_job_cleanup(stats, stats->ojs_cleanup_interval);
 663         return count;
 664 }
 665 EXPORT_SYMBOL(lprocfs_job_interval_seq_write);
 666 #endif /* CONFIG_PROC_FS*/