4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2015, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 #define DEBUG_SUBSYSTEM S_CLASS
38 #include <linux/statfs.h>
39 #include "../include/obd_cksum.h"
40 #include "../include/obd_class.h"
41 #include "../include/lprocfs_status.h"
42 #include <linux/seq_file.h>
43 #include "osc_internal.h"
45 static ssize_t
active_show(struct kobject
*kobj
, struct attribute
*attr
,
48 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
51 return sprintf(buf
, "%d\n", !dev
->u
.cli
.cl_import
->imp_deactive
);
54 static ssize_t
active_store(struct kobject
*kobj
, struct attribute
*attr
,
58 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
63 rc
= kstrtoul(buffer
, 10, &val
);
70 if (dev
->u
.cli
.cl_import
->imp_deactive
== val
)
71 rc
= ptlrpc_set_import_active(dev
->u
.cli
.cl_import
, val
);
73 CDEBUG(D_CONFIG
, "activate %ld: ignoring repeat request\n",
78 LUSTRE_RW_ATTR(active
);
80 static ssize_t
max_rpcs_in_flight_show(struct kobject
*kobj
,
81 struct attribute
*attr
,
84 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
86 struct client_obd
*cli
= &dev
->u
.cli
;
88 return sprintf(buf
, "%u\n", cli
->cl_max_rpcs_in_flight
);
91 static ssize_t
max_rpcs_in_flight_store(struct kobject
*kobj
,
92 struct attribute
*attr
,
96 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
98 struct client_obd
*cli
= &dev
->u
.cli
;
101 int adding
, added
, req_count
;
103 rc
= kstrtoul(buffer
, 10, &val
);
107 if (val
< 1 || val
> OSC_MAX_RIF_MAX
)
110 adding
= val
- cli
->cl_max_rpcs_in_flight
;
111 req_count
= atomic_read(&osc_pool_req_count
);
112 if (adding
> 0 && req_count
< osc_reqpool_maxreqcount
) {
114 * There might be some race which will cause over-limit
115 * allocation, but it is fine.
117 if (req_count
+ adding
> osc_reqpool_maxreqcount
)
118 adding
= osc_reqpool_maxreqcount
- req_count
;
120 added
= osc_rq_pool
->prp_populate(osc_rq_pool
, adding
);
121 atomic_add(added
, &osc_pool_req_count
);
124 client_obd_list_lock(&cli
->cl_loi_list_lock
);
125 cli
->cl_max_rpcs_in_flight
= val
;
126 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
130 LUSTRE_RW_ATTR(max_rpcs_in_flight
);
132 static ssize_t
max_dirty_mb_show(struct kobject
*kobj
,
133 struct attribute
*attr
,
136 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
138 struct client_obd
*cli
= &dev
->u
.cli
;
142 client_obd_list_lock(&cli
->cl_loi_list_lock
);
143 val
= cli
->cl_dirty_max
;
144 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
147 return lprocfs_read_frac_helper(buf
, PAGE_SIZE
, val
, mult
);
150 static ssize_t
max_dirty_mb_store(struct kobject
*kobj
,
151 struct attribute
*attr
,
155 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
157 struct client_obd
*cli
= &dev
->u
.cli
;
159 unsigned long pages_number
;
161 rc
= kstrtoul(buffer
, 10, &pages_number
);
165 pages_number
*= 1 << (20 - PAGE_SHIFT
); /* MB -> pages */
167 if (pages_number
<= 0 ||
168 pages_number
> OSC_MAX_DIRTY_MB_MAX
<< (20 - PAGE_SHIFT
) ||
169 pages_number
> totalram_pages
/ 4) /* 1/4 of RAM */
172 client_obd_list_lock(&cli
->cl_loi_list_lock
);
173 cli
->cl_dirty_max
= (u32
)(pages_number
<< PAGE_SHIFT
);
174 osc_wake_cache_waiters(cli
);
175 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
179 LUSTRE_RW_ATTR(max_dirty_mb
);
181 static int osc_cached_mb_seq_show(struct seq_file
*m
, void *v
)
183 struct obd_device
*dev
= m
->private;
184 struct client_obd
*cli
= &dev
->u
.cli
;
185 int shift
= 20 - PAGE_SHIFT
;
190 (atomic_read(&cli
->cl_lru_in_list
) +
191 atomic_read(&cli
->cl_lru_busy
)) >> shift
,
192 atomic_read(&cli
->cl_lru_busy
));
197 /* shrink the number of caching pages to a specific number */
198 static ssize_t
osc_cached_mb_seq_write(struct file
*file
,
199 const char __user
*buffer
,
200 size_t count
, loff_t
*off
)
202 struct obd_device
*dev
= ((struct seq_file
*)file
->private_data
)->private;
203 struct client_obd
*cli
= &dev
->u
.cli
;
204 int pages_number
, mult
, rc
;
207 if (count
>= sizeof(kernbuf
))
210 if (copy_from_user(kernbuf
, buffer
, count
))
214 mult
= 1 << (20 - PAGE_SHIFT
);
215 buffer
+= lprocfs_find_named_value(kernbuf
, "used_mb:", &count
) -
217 rc
= lprocfs_write_frac_helper(buffer
, count
, &pages_number
, mult
);
221 if (pages_number
< 0)
224 rc
= atomic_read(&cli
->cl_lru_in_list
) - pages_number
;
226 (void)osc_lru_shrink(cli
, rc
);
231 LPROC_SEQ_FOPS(osc_cached_mb
);
233 static ssize_t
cur_dirty_bytes_show(struct kobject
*kobj
,
234 struct attribute
*attr
,
237 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
239 struct client_obd
*cli
= &dev
->u
.cli
;
242 client_obd_list_lock(&cli
->cl_loi_list_lock
);
243 len
= sprintf(buf
, "%lu\n", cli
->cl_dirty
);
244 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
248 LUSTRE_RO_ATTR(cur_dirty_bytes
);
250 static ssize_t
cur_grant_bytes_show(struct kobject
*kobj
,
251 struct attribute
*attr
,
254 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
256 struct client_obd
*cli
= &dev
->u
.cli
;
259 client_obd_list_lock(&cli
->cl_loi_list_lock
);
260 len
= sprintf(buf
, "%lu\n", cli
->cl_avail_grant
);
261 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
266 static ssize_t
cur_grant_bytes_store(struct kobject
*kobj
,
267 struct attribute
*attr
,
271 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
273 struct client_obd
*cli
= &obd
->u
.cli
;
275 unsigned long long val
;
277 rc
= kstrtoull(buffer
, 10, &val
);
281 /* this is only for shrinking grant */
282 client_obd_list_lock(&cli
->cl_loi_list_lock
);
283 if (val
>= cli
->cl_avail_grant
) {
284 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
287 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
289 if (cli
->cl_import
->imp_state
== LUSTRE_IMP_FULL
)
290 rc
= osc_shrink_grant_to_target(cli
, val
);
295 LUSTRE_RW_ATTR(cur_grant_bytes
);
297 static ssize_t
cur_lost_grant_bytes_show(struct kobject
*kobj
,
298 struct attribute
*attr
,
301 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
303 struct client_obd
*cli
= &dev
->u
.cli
;
306 client_obd_list_lock(&cli
->cl_loi_list_lock
);
307 len
= sprintf(buf
, "%lu\n", cli
->cl_lost_grant
);
308 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
312 LUSTRE_RO_ATTR(cur_lost_grant_bytes
);
314 static ssize_t
grant_shrink_interval_show(struct kobject
*kobj
,
315 struct attribute
*attr
,
318 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
321 return sprintf(buf
, "%d\n", obd
->u
.cli
.cl_grant_shrink_interval
);
324 static ssize_t
grant_shrink_interval_store(struct kobject
*kobj
,
325 struct attribute
*attr
,
329 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
334 rc
= kstrtoul(buffer
, 10, &val
);
341 obd
->u
.cli
.cl_grant_shrink_interval
= val
;
345 LUSTRE_RW_ATTR(grant_shrink_interval
);
347 static ssize_t
checksums_show(struct kobject
*kobj
,
348 struct attribute
*attr
,
351 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
354 return sprintf(buf
, "%d\n", obd
->u
.cli
.cl_checksum
? 1 : 0);
357 static ssize_t
checksums_store(struct kobject
*kobj
,
358 struct attribute
*attr
,
362 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
367 rc
= kstrtoul(buffer
, 10, &val
);
371 obd
->u
.cli
.cl_checksum
= (val
? 1 : 0);
375 LUSTRE_RW_ATTR(checksums
);
377 static int osc_checksum_type_seq_show(struct seq_file
*m
, void *v
)
379 struct obd_device
*obd
= m
->private;
387 for (i
= 0; i
< ARRAY_SIZE(cksum_name
); i
++) {
388 if (((1 << i
) & obd
->u
.cli
.cl_supp_cksum_types
) == 0)
390 if (obd
->u
.cli
.cl_cksum_type
== (1 << i
))
391 seq_printf(m
, "[%s] ", cksum_name
[i
]);
393 seq_printf(m
, "%s ", cksum_name
[i
]);
399 static ssize_t
osc_checksum_type_seq_write(struct file
*file
,
400 const char __user
*buffer
,
401 size_t count
, loff_t
*off
)
403 struct obd_device
*obd
= ((struct seq_file
*)file
->private_data
)->private;
412 if (count
> sizeof(kernbuf
) - 1)
414 if (copy_from_user(kernbuf
, buffer
, count
))
416 if (count
> 0 && kernbuf
[count
- 1] == '\n')
417 kernbuf
[count
- 1] = '\0';
419 kernbuf
[count
] = '\0';
421 for (i
= 0; i
< ARRAY_SIZE(cksum_name
); i
++) {
422 if (((1 << i
) & obd
->u
.cli
.cl_supp_cksum_types
) == 0)
424 if (!strcmp(kernbuf
, cksum_name
[i
])) {
425 obd
->u
.cli
.cl_cksum_type
= 1 << i
;
432 LPROC_SEQ_FOPS(osc_checksum_type
);
434 static ssize_t
resend_count_show(struct kobject
*kobj
,
435 struct attribute
*attr
,
438 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
441 return sprintf(buf
, "%u\n", atomic_read(&obd
->u
.cli
.cl_resends
));
444 static ssize_t
resend_count_store(struct kobject
*kobj
,
445 struct attribute
*attr
,
449 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
454 rc
= kstrtoul(buffer
, 10, &val
);
458 atomic_set(&obd
->u
.cli
.cl_resends
, val
);
462 LUSTRE_RW_ATTR(resend_count
);
464 static ssize_t
contention_seconds_show(struct kobject
*kobj
,
465 struct attribute
*attr
,
468 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
470 struct osc_device
*od
= obd2osc_dev(obd
);
472 return sprintf(buf
, "%u\n", od
->od_contention_time
);
475 static ssize_t
contention_seconds_store(struct kobject
*kobj
,
476 struct attribute
*attr
,
480 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
482 struct osc_device
*od
= obd2osc_dev(obd
);
486 rc
= kstrtoint(buffer
, 10, &val
);
493 od
->od_contention_time
= val
;
497 LUSTRE_RW_ATTR(contention_seconds
);
499 static ssize_t
lockless_truncate_show(struct kobject
*kobj
,
500 struct attribute
*attr
,
503 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
505 struct osc_device
*od
= obd2osc_dev(obd
);
507 return sprintf(buf
, "%u\n", od
->od_lockless_truncate
);
510 static ssize_t
lockless_truncate_store(struct kobject
*kobj
,
511 struct attribute
*attr
,
515 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
517 struct osc_device
*od
= obd2osc_dev(obd
);
521 rc
= kstrtouint(buffer
, 10, &val
);
525 od
->od_lockless_truncate
= val
;
529 LUSTRE_RW_ATTR(lockless_truncate
);
531 static ssize_t
destroys_in_flight_show(struct kobject
*kobj
,
532 struct attribute
*attr
,
535 struct obd_device
*obd
= container_of(kobj
, struct obd_device
,
538 return sprintf(buf
, "%u\n",
539 atomic_read(&obd
->u
.cli
.cl_destroy_in_flight
));
541 LUSTRE_RO_ATTR(destroys_in_flight
);
543 static ssize_t
max_pages_per_rpc_show(struct kobject
*kobj
,
544 struct attribute
*attr
,
547 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
549 struct client_obd
*cli
= &dev
->u
.cli
;
551 return sprintf(buf
, "%d\n", cli
->cl_max_pages_per_rpc
);
554 static ssize_t
max_pages_per_rpc_store(struct kobject
*kobj
,
555 struct attribute
*attr
,
559 struct obd_device
*dev
= container_of(kobj
, struct obd_device
,
561 struct client_obd
*cli
= &dev
->u
.cli
;
562 struct obd_connect_data
*ocd
= &cli
->cl_import
->imp_connect_data
;
564 unsigned long long val
;
566 rc
= kstrtoull(buffer
, 10, &val
);
570 /* if the max_pages is specified in bytes, convert to pages */
571 if (val
>= ONE_MB_BRW_SIZE
)
574 chunk_mask
= ~((1 << (cli
->cl_chunkbits
- PAGE_SHIFT
)) - 1);
575 /* max_pages_per_rpc must be chunk aligned */
576 val
= (val
+ ~chunk_mask
) & chunk_mask
;
577 if (val
== 0 || val
> ocd
->ocd_brw_size
>> PAGE_SHIFT
) {
580 client_obd_list_lock(&cli
->cl_loi_list_lock
);
581 cli
->cl_max_pages_per_rpc
= val
;
582 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
586 LUSTRE_RW_ATTR(max_pages_per_rpc
);
588 LPROC_SEQ_FOPS_RO_TYPE(osc
, connect_flags
);
589 LPROC_SEQ_FOPS_RO_TYPE(osc
, server_uuid
);
590 LPROC_SEQ_FOPS_RO_TYPE(osc
, conn_uuid
);
591 LPROC_SEQ_FOPS_RO_TYPE(osc
, timeouts
);
592 LPROC_SEQ_FOPS_RO_TYPE(osc
, state
);
594 LPROC_SEQ_FOPS_WR_ONLY(osc
, ping
);
596 LPROC_SEQ_FOPS_RW_TYPE(osc
, import
);
597 LPROC_SEQ_FOPS_RW_TYPE(osc
, pinger_recov
);
599 static struct lprocfs_vars lprocfs_osc_obd_vars
[] = {
600 { "ping", &osc_ping_fops
, NULL
, 0222 },
601 { "connect_flags", &osc_connect_flags_fops
, NULL
, 0 },
602 /*{ "filegroups", lprocfs_rd_filegroups, NULL, 0 },*/
603 { "ost_server_uuid", &osc_server_uuid_fops
, NULL
, 0 },
604 { "ost_conn_uuid", &osc_conn_uuid_fops
, NULL
, 0 },
605 { "osc_cached_mb", &osc_cached_mb_fops
, NULL
},
606 { "checksum_type", &osc_checksum_type_fops
, NULL
},
607 { "timeouts", &osc_timeouts_fops
, NULL
, 0 },
608 { "import", &osc_import_fops
, NULL
},
609 { "state", &osc_state_fops
, NULL
, 0 },
610 { "pinger_recov", &osc_pinger_recov_fops
, NULL
},
614 #define pct(a, b) (b ? a * 100 / b : 0)
616 static int osc_rpc_stats_seq_show(struct seq_file
*seq
, void *v
)
618 struct timespec64 now
;
619 struct obd_device
*dev
= seq
->private;
620 struct client_obd
*cli
= &dev
->u
.cli
;
621 unsigned long read_tot
= 0, write_tot
= 0, read_cum
, write_cum
;
624 ktime_get_real_ts64(&now
);
626 client_obd_list_lock(&cli
->cl_loi_list_lock
);
628 seq_printf(seq
, "snapshot_time: %llu.%9lu (secs.usecs)\n",
629 (s64
)now
.tv_sec
, (unsigned long)now
.tv_nsec
);
630 seq_printf(seq
, "read RPCs in flight: %d\n",
631 cli
->cl_r_in_flight
);
632 seq_printf(seq
, "write RPCs in flight: %d\n",
633 cli
->cl_w_in_flight
);
634 seq_printf(seq
, "pending write pages: %d\n",
635 atomic_read(&cli
->cl_pending_w_pages
));
636 seq_printf(seq
, "pending read pages: %d\n",
637 atomic_read(&cli
->cl_pending_r_pages
));
639 seq_puts(seq
, "\n\t\t\tread\t\t\twrite\n");
640 seq_puts(seq
, "pages per rpc rpcs % cum % |");
641 seq_puts(seq
, " rpcs % cum %\n");
643 read_tot
= lprocfs_oh_sum(&cli
->cl_read_page_hist
);
644 write_tot
= lprocfs_oh_sum(&cli
->cl_write_page_hist
);
648 for (i
= 0; i
< OBD_HIST_MAX
; i
++) {
649 unsigned long r
= cli
->cl_read_page_hist
.oh_buckets
[i
];
650 unsigned long w
= cli
->cl_write_page_hist
.oh_buckets
[i
];
654 seq_printf(seq
, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n",
655 1 << i
, r
, pct(r
, read_tot
),
656 pct(read_cum
, read_tot
), w
,
658 pct(write_cum
, write_tot
));
659 if (read_cum
== read_tot
&& write_cum
== write_tot
)
663 seq_puts(seq
, "\n\t\t\tread\t\t\twrite\n");
664 seq_puts(seq
, "rpcs in flight rpcs % cum % |");
665 seq_puts(seq
, " rpcs % cum %\n");
667 read_tot
= lprocfs_oh_sum(&cli
->cl_read_rpc_hist
);
668 write_tot
= lprocfs_oh_sum(&cli
->cl_write_rpc_hist
);
672 for (i
= 0; i
< OBD_HIST_MAX
; i
++) {
673 unsigned long r
= cli
->cl_read_rpc_hist
.oh_buckets
[i
];
674 unsigned long w
= cli
->cl_write_rpc_hist
.oh_buckets
[i
];
678 seq_printf(seq
, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n",
679 i
, r
, pct(r
, read_tot
),
680 pct(read_cum
, read_tot
), w
,
682 pct(write_cum
, write_tot
));
683 if (read_cum
== read_tot
&& write_cum
== write_tot
)
687 seq_puts(seq
, "\n\t\t\tread\t\t\twrite\n");
688 seq_puts(seq
, "offset rpcs % cum % |");
689 seq_puts(seq
, " rpcs % cum %\n");
691 read_tot
= lprocfs_oh_sum(&cli
->cl_read_offset_hist
);
692 write_tot
= lprocfs_oh_sum(&cli
->cl_write_offset_hist
);
696 for (i
= 0; i
< OBD_HIST_MAX
; i
++) {
697 unsigned long r
= cli
->cl_read_offset_hist
.oh_buckets
[i
];
698 unsigned long w
= cli
->cl_write_offset_hist
.oh_buckets
[i
];
702 seq_printf(seq
, "%d:\t\t%10lu %3lu %3lu | %10lu %3lu %3lu\n",
703 (i
== 0) ? 0 : 1 << (i
- 1),
704 r
, pct(r
, read_tot
), pct(read_cum
, read_tot
),
705 w
, pct(w
, write_tot
), pct(write_cum
, write_tot
));
706 if (read_cum
== read_tot
&& write_cum
== write_tot
)
710 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
717 static ssize_t
osc_rpc_stats_seq_write(struct file
*file
,
718 const char __user
*buf
,
719 size_t len
, loff_t
*off
)
721 struct seq_file
*seq
= file
->private_data
;
722 struct obd_device
*dev
= seq
->private;
723 struct client_obd
*cli
= &dev
->u
.cli
;
725 lprocfs_oh_clear(&cli
->cl_read_rpc_hist
);
726 lprocfs_oh_clear(&cli
->cl_write_rpc_hist
);
727 lprocfs_oh_clear(&cli
->cl_read_page_hist
);
728 lprocfs_oh_clear(&cli
->cl_write_page_hist
);
729 lprocfs_oh_clear(&cli
->cl_read_offset_hist
);
730 lprocfs_oh_clear(&cli
->cl_write_offset_hist
);
735 LPROC_SEQ_FOPS(osc_rpc_stats
);
737 static int osc_stats_seq_show(struct seq_file
*seq
, void *v
)
739 struct timespec64 now
;
740 struct obd_device
*dev
= seq
->private;
741 struct osc_stats
*stats
= &obd2osc_dev(dev
)->od_stats
;
743 ktime_get_real_ts64(&now
);
745 seq_printf(seq
, "snapshot_time: %llu.%9lu (secs.usecs)\n",
746 (s64
)now
.tv_sec
, (unsigned long)now
.tv_nsec
);
747 seq_printf(seq
, "lockless_write_bytes\t\t%llu\n",
748 stats
->os_lockless_writes
);
749 seq_printf(seq
, "lockless_read_bytes\t\t%llu\n",
750 stats
->os_lockless_reads
);
751 seq_printf(seq
, "lockless_truncate\t\t%llu\n",
752 stats
->os_lockless_truncates
);
756 static ssize_t
osc_stats_seq_write(struct file
*file
,
757 const char __user
*buf
,
758 size_t len
, loff_t
*off
)
760 struct seq_file
*seq
= file
->private_data
;
761 struct obd_device
*dev
= seq
->private;
762 struct osc_stats
*stats
= &obd2osc_dev(dev
)->od_stats
;
764 memset(stats
, 0, sizeof(*stats
));
768 LPROC_SEQ_FOPS(osc_stats
);
770 int lproc_osc_attach_seqstat(struct obd_device
*dev
)
774 rc
= ldebugfs_seq_create(dev
->obd_debugfs_entry
, "osc_stats", 0644,
775 &osc_stats_fops
, dev
);
777 rc
= ldebugfs_obd_seq_create(dev
, "rpc_stats", 0644,
778 &osc_rpc_stats_fops
, dev
);
783 static struct attribute
*osc_attrs
[] = {
784 &lustre_attr_active
.attr
,
785 &lustre_attr_checksums
.attr
,
786 &lustre_attr_contention_seconds
.attr
,
787 &lustre_attr_cur_dirty_bytes
.attr
,
788 &lustre_attr_cur_grant_bytes
.attr
,
789 &lustre_attr_cur_lost_grant_bytes
.attr
,
790 &lustre_attr_destroys_in_flight
.attr
,
791 &lustre_attr_grant_shrink_interval
.attr
,
792 &lustre_attr_lockless_truncate
.attr
,
793 &lustre_attr_max_dirty_mb
.attr
,
794 &lustre_attr_max_pages_per_rpc
.attr
,
795 &lustre_attr_max_rpcs_in_flight
.attr
,
796 &lustre_attr_resend_count
.attr
,
800 static struct attribute_group osc_attr_group
= {
804 void lprocfs_osc_init_vars(struct lprocfs_static_vars
*lvars
)
806 lvars
->sysfs_vars
= &osc_attr_group
;
807 lvars
->obd_vars
= lprocfs_osc_obd_vars
;