Whamcloud - gitweb
LU-8130 ptlrpc: convert conn_hash to rhashtable
[fs/lustre-release.git] / lustre / include / lustre_net.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
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.
9  *
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).
15  *
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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2010, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  */
32 /** \defgroup PtlRPC Portal RPC and networking module.
33  *
34  * PortalRPC is the layer used by rest of lustre code to achieve network
35  * communications: establish connections with corresponding export and import
36  * states, listen for a service, send and receive RPCs.
37  * PortalRPC also includes base recovery framework: packet resending and
38  * replaying, reconnections, pinger.
39  *
40  * PortalRPC utilizes LNet as its transport layer.
41  *
42  * @{
43  */
44
45
46 #ifndef _LUSTRE_NET_H
47 #define _LUSTRE_NET_H
48
49 /** \defgroup net net
50  *
51  * @{
52  */
53 #include <linux/kobject.h>
54 #include <linux/rhashtable.h>
55 #include <linux/uio.h>
56 #include <libcfs/libcfs.h>
57 #include <lnet/api.h>
58 #include <lnet/lib-types.h>
59 #include <uapi/linux/lnet/nidstr.h>
60 #include <uapi/linux/lustre/lustre_idl.h>
61 #include <lustre_ha.h>
62 #include <lustre_sec.h>
63 #include <lustre_import.h>
64 #include <lprocfs_status.h>
65 #include <lu_object.h>
66 #include <lustre_req_layout.h>
67 #include <obd_support.h>
68 #include <uapi/linux/lustre/lustre_ver.h>
69
70 /* MD flags we _always_ use */
71 #define PTLRPC_MD_OPTIONS  0
72
73 /**
74  * log2 max # of bulk operations in one request: 2=4MB/RPC, 5=32MB/RPC, ...
75  * In order for the client and server to properly negotiate the maximum
76  * possible transfer size, PTLRPC_BULK_OPS_COUNT must be a power-of-two
77  * value.  The client is free to limit the actual RPC size for any bulk
78  * transfer via cl_max_pages_per_rpc to some non-power-of-two value.
79  * NOTE: This is limited to 16 (=64GB RPCs) by IOOBJ_MAX_BRW_BITS. */
80 #define PTLRPC_BULK_OPS_BITS    6
81 #if PTLRPC_BULK_OPS_BITS > 16
82 #error "More than 65536 BRW RPCs not allowed by IOOBJ_MAX_BRW_BITS."
83 #endif
84 #define PTLRPC_BULK_OPS_COUNT   (1U << PTLRPC_BULK_OPS_BITS)
85 /**
86  * PTLRPC_BULK_OPS_MASK is for the convenience of the client only, and
87  * should not be used on the server at all.  Otherwise, it imposes a
88  * protocol limitation on the maximum RPC size that can be used by any
89  * RPC sent to that server in the future.  Instead, the server should
90  * use the negotiated per-client ocd_brw_size to determine the bulk
91  * RPC count. */
92 #define PTLRPC_BULK_OPS_MASK    (~((__u64)PTLRPC_BULK_OPS_COUNT - 1))
93
94 /**
95  * Define maxima for bulk I/O.
96  *
97  * A single PTLRPC BRW request is sent via up to PTLRPC_BULK_OPS_COUNT
98  * of LNET_MTU sized RDMA transfers.  Clients and servers negotiate the
99  * currently supported maximum between peers at connect via ocd_brw_size.
100  */
101 #define PTLRPC_MAX_BRW_BITS     (LNET_MTU_BITS + PTLRPC_BULK_OPS_BITS)
102 #define PTLRPC_MAX_BRW_SIZE     (1U << PTLRPC_MAX_BRW_BITS)
103 #define PTLRPC_MAX_BRW_PAGES    (PTLRPC_MAX_BRW_SIZE >> PAGE_SHIFT)
104
105 #define ONE_MB_BRW_SIZE         (1U << LNET_MTU_BITS)
106 #define MD_MAX_BRW_SIZE         (1U << LNET_MTU_BITS)
107 #define MD_MAX_BRW_PAGES        (MD_MAX_BRW_SIZE >> PAGE_SHIFT)
108 #define DT_MAX_BRW_SIZE         PTLRPC_MAX_BRW_SIZE
109 #define DT_DEF_BRW_SIZE         (4 * ONE_MB_BRW_SIZE)
110 #define DT_MAX_BRW_PAGES        (DT_MAX_BRW_SIZE >> PAGE_SHIFT)
111 #define OFD_MAX_BRW_SIZE        (1U << LNET_MTU_BITS)
112
113 /* When PAGE_SIZE is a constant, we can check our arithmetic here with cpp! */
114 #if ((PTLRPC_MAX_BRW_PAGES & (PTLRPC_MAX_BRW_PAGES - 1)) != 0)
115 # error "PTLRPC_MAX_BRW_PAGES isn't a power of two"
116 #endif
117 #if (PTLRPC_MAX_BRW_SIZE != (PTLRPC_MAX_BRW_PAGES * PAGE_SIZE))
118 # error "PTLRPC_MAX_BRW_SIZE isn't PTLRPC_MAX_BRW_PAGES * PAGE_SIZE"
119 #endif
120 #if (PTLRPC_MAX_BRW_SIZE > LNET_MTU * PTLRPC_BULK_OPS_COUNT)
121 # error "PTLRPC_MAX_BRW_SIZE too big"
122 #endif
123 #if (PTLRPC_MAX_BRW_PAGES > LNET_MAX_IOV * PTLRPC_BULK_OPS_COUNT)
124 # error "PTLRPC_MAX_BRW_PAGES too big"
125 #endif
126
127 #define PTLRPC_NTHRS_INIT       2
128
129 /**
130  * Buffer Constants
131  *
132  * Constants determine how memory is used to buffer incoming service requests.
133  *
134  * ?_NBUFS              # buffers to allocate when growing the pool
135  * ?_BUFSIZE            # bytes in a single request buffer
136  * ?_MAXREQSIZE         # maximum request service will receive
137  *
138  * When fewer than ?_NBUFS/2 buffers are posted for receive, another chunk
139  * of ?_NBUFS is added to the pool.
140  *
141  * Messages larger than ?_MAXREQSIZE are dropped.  Request buffers are
142  * considered full when less than ?_MAXREQSIZE is left in them.
143  */
144 /**
145  * Thread Constants
146  *
147  * Constants determine how threads are created for ptlrpc service.
148  *
149  * ?_NTHRS_INIT         # threads to create for each service partition on
150  *                        initializing. If it's non-affinity service and
151  *                        there is only one partition, it's the overall #
152  *                        threads for the service while initializing.
153  * ?_NTHRS_BASE         # threads should be created at least for each
154  *                        ptlrpc partition to keep the service healthy.
155  *                        It's the low-water mark of threads upper-limit
156  *                        for each partition.
157  * ?_THR_FACTOR         # threads can be added on threads upper-limit for
158  *                        each CPU core. This factor is only for reference,
159  *                        we might decrease value of factor if number of cores
160  *                        per CPT is above a limit.
161  * ?_NTHRS_MAX          # overall threads can be created for a service,
162  *                        it's a soft limit because if service is running
163  *                        on machine with hundreds of cores and tens of
164  *                        CPU partitions, we need to guarantee each partition
165  *                        has ?_NTHRS_BASE threads, which means total threads
166  *                        will be ?_NTHRS_BASE * number_of_cpts which can
167  *                        exceed ?_NTHRS_MAX.
168  *
169  * Examples
170  *
171  * #define MDS_NTHRS_INIT       2
172  * #define MDS_NTHRS_BASE       64
173  * #define MDS_NTHRS_FACTOR     8
174  * #define MDS_NTHRS_MAX        1024
175  *
176  * Example 1):
177  * ---------------------------------------------------------------------
178  * Server(A) has 16 cores, user configured it to 4 partitions so each
179  * partition has 4 cores, then actual number of service threads on each
180  * partition is:
181  *     MDS_NTHRS_BASE(64) + cores(4) * MDS_NTHRS_FACTOR(8) = 96
182  *
183  * Total number of threads for the service is:
184  *     96 * partitions(4) = 384
185  *
186  * Example 2):
187  * ---------------------------------------------------------------------
188  * Server(B) has 32 cores, user configured it to 4 partitions so each
189  * partition has 8 cores, then actual number of service threads on each
190  * partition is:
191  *     MDS_NTHRS_BASE(64) + cores(8) * MDS_NTHRS_FACTOR(8) = 128
192  *
193  * Total number of threads for the service is:
194  *     128 * partitions(4) = 512
195  *
196  * Example 3):
197  * ---------------------------------------------------------------------
198  * Server(B) has 96 cores, user configured it to 8 partitions so each
199  * partition has 12 cores, then actual number of service threads on each
200  * partition is:
201  *     MDS_NTHRS_BASE(64) + cores(12) * MDS_NTHRS_FACTOR(8) = 160
202  *
203  * Total number of threads for the service is:
204  *     160 * partitions(8) = 1280
205  *
206  * However, it's above the soft limit MDS_NTHRS_MAX, so we choose this number
207  * as upper limit of threads number for each partition:
208  *     MDS_NTHRS_MAX(1024) / partitions(8) = 128
209  *
210  * Example 4):
211  * ---------------------------------------------------------------------
212  * Server(C) have a thousand of cores and user configured it to 32 partitions
213  *     MDS_NTHRS_BASE(64) * 32 = 2048
214  *
215  * which is already above soft limit MDS_NTHRS_MAX(1024), but we still need
216  * to guarantee that each partition has at least MDS_NTHRS_BASE(64) threads
217  * to keep service healthy, so total number of threads will just be 2048.
218  *
219  * NB: we don't suggest to choose server with that many cores because backend
220  *     filesystem itself, buffer cache, or underlying network stack might
221  *     have some SMP scalability issues at that large scale.
222  *
223  *     If user already has a fat machine with hundreds or thousands of cores,
224  *     there are two choices for configuration:
225  *     a) create CPU table from subset of all CPUs and run Lustre on
226  *        top of this subset
227  *     b) bind service threads on a few partitions, see modparameters of
228  *        MDS and OSS for details
229 *
230  * NB: these calculations (and examples below) are simplified to help
231  *     understanding, the real implementation is a little more complex,
232  *     please see ptlrpc_server_nthreads_check() for details.
233  *
234  */
235
236  /*
237   * LDLM threads constants:
238   *
239   * Given 8 as factor and 24 as base threads number
240   *
241   * example 1)
242   * On 4-core machine we will have 24 + 8 * 4 = 56 threads.
243   *
244   * example 2)
245   * On 8-core machine with 2 partitions we will have 24 + 4 * 8 = 56
246   * threads for each partition and total threads number will be 112.
247   *
248   * example 3)
249   * On 64-core machine with 8 partitions we will need LDLM_NTHRS_BASE(24)
250   * threads for each partition to keep service healthy, so total threads
251   * number should be 24 * 8 = 192.
252   *
253   * So with these constants, threads number will be at the similar level
254   * of old versions, unless target machine has over a hundred cores
255   */
256 #define LDLM_THR_FACTOR         8
257 #define LDLM_NTHRS_INIT         PTLRPC_NTHRS_INIT
258 #define LDLM_NTHRS_BASE         24
259 #define LDLM_NTHRS_MAX          (num_online_cpus() == 1 ? 64 : 128)
260
261 #define LDLM_BL_THREADS   LDLM_NTHRS_AUTO_INIT
262 #define LDLM_CLIENT_NBUFS 1
263 #define LDLM_SERVER_NBUFS 64
264 #define LDLM_BUFSIZE      (8 * 1024)
265 #define LDLM_MAXREQSIZE   (5 * 1024)
266 #define LDLM_MAXREPSIZE   (1024)
267
268  /*
269   * MDS threads constants:
270   *
271   * Please see examples in "Thread Constants", MDS threads number will be at
272   * the comparable level of old versions, unless the server has many cores.
273   */
274 #ifndef MDS_MAX_THREADS
275 #define MDS_MAX_THREADS         1024
276 #define MDS_MAX_OTHR_THREADS    256
277
278 #else /* MDS_MAX_THREADS */
279 #if MDS_MAX_THREADS < PTLRPC_NTHRS_INIT
280 #undef MDS_MAX_THREADS
281 #define MDS_MAX_THREADS PTLRPC_NTHRS_INIT
282 #endif
283 #define MDS_MAX_OTHR_THREADS    max(PTLRPC_NTHRS_INIT, MDS_MAX_THREADS / 2)
284 #endif
285
286 /* default service */
287 #define MDS_THR_FACTOR          8
288 #define MDS_NTHRS_INIT          PTLRPC_NTHRS_INIT
289 #define MDS_NTHRS_MAX           MDS_MAX_THREADS
290 #define MDS_NTHRS_BASE          min(64, MDS_NTHRS_MAX)
291
292 /* read-page service */
293 #define MDS_RDPG_THR_FACTOR     4
294 #define MDS_RDPG_NTHRS_INIT     PTLRPC_NTHRS_INIT
295 #define MDS_RDPG_NTHRS_MAX      MDS_MAX_OTHR_THREADS
296 #define MDS_RDPG_NTHRS_BASE     min(48, MDS_RDPG_NTHRS_MAX)
297
298 /* these should be removed when we remove setattr service in the future */
299 #define MDS_SETA_THR_FACTOR     4
300 #define MDS_SETA_NTHRS_INIT     PTLRPC_NTHRS_INIT
301 #define MDS_SETA_NTHRS_MAX      MDS_MAX_OTHR_THREADS
302 #define MDS_SETA_NTHRS_BASE     min(48, MDS_SETA_NTHRS_MAX)
303
304 /* non-affinity threads */
305 #define MDS_OTHR_NTHRS_INIT     PTLRPC_NTHRS_INIT
306 #define MDS_OTHR_NTHRS_MAX      MDS_MAX_OTHR_THREADS
307
308 #define MDS_NBUFS               64
309
310 /**
311  * Assume file name length = FNAME_MAX = 256 (true for ext3).
312  *        path name length = PATH_MAX = 4096
313  *        LOV MD size max  = EA_MAX = 24 * 2000
314  *              (NB: 24 is size of lov_ost_data)
315  *        LOV LOGCOOKIE size max = 32 * 2000
316  *              (NB: 32 is size of llog_cookie)
317  * symlink:  FNAME_MAX + PATH_MAX  <- largest
318  * link:     FNAME_MAX + PATH_MAX  (mds_rec_link < mds_rec_create)
319  * rename:   FNAME_MAX + FNAME_MAX
320  * open:     FNAME_MAX + EA_MAX
321  *
322  * MDS_MAXREQSIZE ~= 4736 bytes =
323  * lustre_msg + ldlm_request + mdt_body + mds_rec_create + FNAME_MAX + PATH_MAX
324  * MDS_MAXREPSIZE ~= 8300 bytes = lustre_msg + llog_header
325  *
326  * Realistic size is about 512 bytes (20 character name + 128 char symlink),
327  * except in the open case where there are a large number of OSTs in a LOV.
328  */
329 #define MDS_MAXREQSIZE          (5 * 1024)      /* >= 4736 */
330 #define MDS_MAXREPSIZE          (9 * 1024)      /* >= 8300 */
331
332 /**
333  * MDS incoming request with LOV EA
334  * 24 = sizeof(struct lov_ost_data), i.e: replay of opencreate
335  */
336 #define MDS_LOV_MAXREQSIZE      max(MDS_MAXREQSIZE, \
337                                     362 + LOV_MAX_STRIPE_COUNT * 24)
338 /**
339  * MDS outgoing reply with LOV EA
340  *
341  * NB: max reply size Lustre 2.4+ client can get from old MDS is:
342  * LOV_MAX_STRIPE_COUNT * (llog_cookie + lov_ost_data) + extra bytes
343  *
344  * but 2.4 or later MDS will never send reply with llog_cookie to any
345  * version client. This macro is defined for server side reply buffer size.
346  */
347 #define MDS_LOV_MAXREPSIZE      MDS_LOV_MAXREQSIZE
348
349 /**
350  * This is the size of a maximum REINT_SETXATTR request:
351  *
352  *   lustre_msg          56 (32 + 4 x 5 + 4)
353  *   ptlrpc_body        184
354  *   mdt_rec_setxattr   136
355  *   lustre_capa        120
356  *   name               256 (XATTR_NAME_MAX)
357  *   value            65536 (XATTR_SIZE_MAX)
358  */
359 #define MDS_EA_MAXREQSIZE       66288
360
361 /**
362  * These are the maximum request and reply sizes (rounded up to 1 KB
363  * boundaries) for the "regular" MDS_REQUEST_PORTAL and MDS_REPLY_PORTAL.
364  */
365 #define MDS_REG_MAXREQSIZE      (((max(MDS_EA_MAXREQSIZE, \
366                                        MDS_LOV_MAXREQSIZE) + 1023) >> 10) << 10)
367 #define MDS_REG_MAXREPSIZE      MDS_REG_MAXREQSIZE
368
369 /**
370  * The update request includes all of updates from the create, which might
371  * include linkea (4K maxim), together with other updates, we set it to 1000K:
372  * lustre_msg + ptlrpc_body + OUT_UPDATE_BUFFER_SIZE_MAX
373  */
374 #define OUT_MAXREQSIZE  (1000 * 1024)
375 #define OUT_MAXREPSIZE  MDS_MAXREPSIZE
376
377 /** MDS_BUFSIZE = max_reqsize (w/o LOV EA) + max sptlrpc payload size */
378 #define MDS_BUFSIZE             max(MDS_MAXREQSIZE + SPTLRPC_MAX_PAYLOAD, \
379                                     8 * 1024)
380
381 /**
382  * MDS_REG_BUFSIZE should at least be MDS_REG_MAXREQSIZE + SPTLRPC_MAX_PAYLOAD.
383  * However, we need to allocate a much larger buffer for it because LNet
384  * requires each MD(rqbd) has at least MDS_REQ_MAXREQSIZE bytes left to avoid
385  * dropping of maximum-sized incoming request.  So if MDS_REG_BUFSIZE is only a
386  * little larger than MDS_REG_MAXREQSIZE, then it can only fit in one request
387  * even there are about MDS_REG_MAX_REQSIZE bytes left in a rqbd, and memory
388  * utilization is very low.
389  *
390  * In the meanwhile, size of rqbd can't be too large, because rqbd can't be
391  * reused until all requests fit in it have been processed and released,
392  * which means one long blocked request can prevent the rqbd be reused.
393  * Now we set request buffer size to 160 KB, so even each rqbd is unlinked
394  * from LNet with unused 65 KB, buffer utilization will be about 59%.
395  * Please check LU-2432 for details.
396  */
397 #define MDS_REG_BUFSIZE         max(MDS_REG_MAXREQSIZE + SPTLRPC_MAX_PAYLOAD, \
398                                     160 * 1024)
399
400 /**
401  * OUT_BUFSIZE = max_out_reqsize + max sptlrpc payload (~1K) which is
402  * about 10K, for the same reason as MDS_REG_BUFSIZE, we also give some
403  * extra bytes to each request buffer to improve buffer utilization rate.
404   */
405 #define OUT_BUFSIZE             max(OUT_MAXREQSIZE + SPTLRPC_MAX_PAYLOAD, \
406                                     24 * 1024)
407
408 /** FLD_MAXREQSIZE == lustre_msg + __u32 padding + ptlrpc_body + opc */
409 #define FLD_MAXREQSIZE  (160)
410
411 /** FLD_MAXREPSIZE == lustre_msg + ptlrpc_body */
412 #define FLD_MAXREPSIZE  (152)
413 #define FLD_BUFSIZE     (1 << 12)
414
415 /**
416  * SEQ_MAXREQSIZE == lustre_msg + __u32 padding + ptlrpc_body + opc + lu_range +
417  * __u32 padding */
418 #define SEQ_MAXREQSIZE  (160)
419
420 /** SEQ_MAXREPSIZE == lustre_msg + ptlrpc_body + lu_range */
421 #define SEQ_MAXREPSIZE  (152)
422 #define SEQ_BUFSIZE     (1 << 12)
423
424 /** MGS threads must be >= 3, see bug 22458 comment #28 */
425 #define MGS_NTHRS_INIT  (PTLRPC_NTHRS_INIT + 1)
426 #define MGS_NTHRS_MAX   32
427
428 #define MGS_NBUFS       64
429 #define MGS_BUFSIZE     (8 * 1024)
430 #define MGS_MAXREQSIZE  (7 * 1024)
431 #define MGS_MAXREPSIZE  (9 * 1024)
432
433  /*
434   * OSS threads constants:
435   *
436   * Given 8 as factor and 64 as base threads number
437   *
438   * example 1):
439   * On 8-core server configured to 2 partitions, we will have
440   * 64 + 8 * 4 = 96 threads for each partition, 192 total threads.
441   *
442   * example 2):
443   * On 32-core machine configured to 4 partitions, we will have
444   * 64 + 8 * 8 = 112 threads for each partition, so total threads number
445   * will be 112 * 4 = 448.
446   *
447   * example 3):
448   * On 64-core machine configured to 4 partitions, we will have
449   * 64 + 16 * 8 = 192 threads for each partition, so total threads number
450   * will be 192 * 4 = 768 which is above limit OSS_NTHRS_MAX(512), so we
451   * cut off the value to OSS_NTHRS_MAX(512) / 4 which is 128 threads
452   * for each partition.
453   *
454   * So we can see that with these constants, threads number wil be at the
455   * similar level of old versions, unless the server has many cores.
456   */
457  /* depress threads factor for VM with small memory size */
458 #define OSS_THR_FACTOR          min_t(int, 8, \
459                                 NUM_CACHEPAGES >> (28 - PAGE_SHIFT))
460 #define OSS_NTHRS_INIT          (PTLRPC_NTHRS_INIT + 1)
461 #define OSS_NTHRS_BASE          64
462
463 /* threads for handling "create" request */
464 #define OSS_CR_THR_FACTOR       1
465 #define OSS_CR_NTHRS_INIT       PTLRPC_NTHRS_INIT
466 #define OSS_CR_NTHRS_BASE       8
467 #define OSS_CR_NTHRS_MAX        64
468
469 /**
470  * OST_IO_MAXREQSIZE ~=
471  *      lustre_msg + ptlrpc_body + obdo + obd_ioobj +
472  *      DT_MAX_BRW_PAGES * niobuf_remote
473  *
474  * - single object with 16 pages is 512 bytes
475  * - OST_IO_MAXREQSIZE must be at least 1 niobuf per page of data
476  * - Must be a multiple of 1024
477  * - should allow a reasonably large SHORT_IO_BYTES size (64KB)
478  */
479 #define _OST_MAXREQSIZE_BASE ((unsigned long)(sizeof(struct lustre_msg)   + \
480                              /* lm_buflens */ sizeof(__u32) * 4           + \
481                                               sizeof(struct ptlrpc_body)  + \
482                                               sizeof(struct obdo)         + \
483                                               sizeof(struct obd_ioobj)    + \
484                                               sizeof(struct niobuf_remote)))
485 #define _OST_MAXREQSIZE_SUM ((unsigned long)(_OST_MAXREQSIZE_BASE         + \
486                                              sizeof(struct niobuf_remote) * \
487                                              DT_MAX_BRW_PAGES))
488 /**
489  * FIEMAP request can be 4K+ for now
490  */
491 #define OST_MAXREQSIZE          (16UL * 1024UL)
492 #define OST_IO_MAXREQSIZE       max(OST_MAXREQSIZE,                     \
493                                    ((_OST_MAXREQSIZE_SUM - 1) |         \
494                                     (1024UL - 1)) + 1)
495 /* Safe estimate of free space in standard RPC, provides upper limit for # of
496  * bytes of i/o to pack in RPC (skipping bulk transfer). */
497 #define OST_MAX_SHORT_IO_BYTES  ((OST_IO_MAXREQSIZE - _OST_MAXREQSIZE_BASE) & \
498                                  PAGE_MASK)
499
500 /* Actual size used for short i/o buffer.  Calculation means this:
501  * At least one page (for large PAGE_SIZE), or 16 KiB, but not more
502  * than the available space aligned to a page boundary. */
503 #define OBD_DEF_SHORT_IO_BYTES  min(max(PAGE_SIZE, 16UL * 1024UL), \
504                                     OST_MAX_SHORT_IO_BYTES)
505
506 #define OST_MAXREPSIZE          (9 * 1024)
507 #define OST_IO_MAXREPSIZE       OST_MAXREPSIZE
508
509 #define OST_NBUFS               64
510 /** OST_BUFSIZE = max_reqsize + max sptlrpc payload size */
511 #define OST_BUFSIZE             max_t(int, OST_MAXREQSIZE + 1024, 32 * 1024)
512 /**
513  * OST_IO_MAXREQSIZE is 18K, giving extra 46K can increase buffer utilization
514  * rate of request buffer, please check comment of MDS_LOV_BUFSIZE for details.
515  */
516 #define OST_IO_BUFSIZE          max_t(int, OST_IO_MAXREQSIZE + 1024, 64 * 1024)
517
518 /* Macro to hide a typecast and BUILD_BUG. */
519 #define ptlrpc_req_async_args(_var, req) ({                             \
520                 BUILD_BUG_ON(sizeof(*_var) > sizeof(req->rq_async_args)); \
521                 (typeof(_var))&req->rq_async_args;                      \
522         })
523
524 struct ptlrpc_replay_async_args {
525         int             praa_old_state;
526         int             praa_old_status;
527 };
528
529 /**
530  * Structure to single define portal connection.
531  */
532 struct ptlrpc_connection {
533         /** linkage for connections hash table */
534         struct rhash_head       c_hash;
535         /** Our own lnet nid for this connection */
536         lnet_nid_t              c_self;
537         /** Remote side nid for this connection */
538         struct lnet_process_id       c_peer;
539         /** UUID of the other side */
540         struct obd_uuid         c_remote_uuid;
541         /** reference counter for this connection */
542         atomic_t            c_refcount;
543 };
544
545 /** Client definition for PortalRPC */
546 struct ptlrpc_client {
547         /** What lnet portal does this client send messages to by default */
548         __u32                   cli_request_portal;
549         /** What portal do we expect replies on */
550         __u32                   cli_reply_portal;
551         /** Name of the client */
552         const char              *cli_name;
553 };
554
555 /** state flags of requests */
556 /* XXX only ones left are those used by the bulk descs as well! */
557 #define PTL_RPC_FL_INTR         BIT(0)  /* reply wait was interrupted by user */
558 #define PTL_RPC_FL_TIMEOUT      BIT(7)  /* request timed out waiting for reply */
559
560 #define REQ_MAX_ACK_LOCKS 8
561
562 union ptlrpc_async_args {
563         /**
564          * Scratchpad for passing args to completion interpreter. Users
565          * cast to the struct of their choosing, and BUILD_BUG_ON that this is
566          * big enough.  For _tons_ of context, OBD_ALLOC a struct and store
567          * a pointer to it here.  The pointer_arg ensures this struct is at
568          * least big enough for that.
569          */
570         void    *pointer_arg[11];
571         __u64   space[7];
572 };
573
574 struct ptlrpc_request_set;
575 typedef int (*set_producer_func)(struct ptlrpc_request_set *, void *);
576
577 /**
578  * Definition of request set structure.
579  * Request set is a list of requests (not necessary to the same target) that
580  * once populated with RPCs could be sent in parallel.
581  * There are two kinds of request sets. General purpose and with dedicated
582  * serving thread. Example of the latter is ptlrpcd set.
583  * For general purpose sets once request set started sending it is impossible
584  * to add new requests to such set.
585  * Provides a way to call "completion callbacks" when all requests in the set
586  * returned.
587  */
588 struct ptlrpc_request_set {
589         atomic_t                set_refcount;
590         /** number of in queue requests */
591         atomic_t                set_new_count;
592         /** number of uncompleted requests */
593         atomic_t                set_remaining;
594         /** wait queue to wait on for request events */
595         wait_queue_head_t       set_waitq;
596         /** List of requests in the set */
597         struct list_head        set_requests;
598         /**
599          * Lock for \a set_new_requests manipulations
600          * locked so that any old caller can communicate requests to
601          * the set holder who can then fold them into the lock-free set
602          */
603         spinlock_t              set_new_req_lock;
604         /** List of new yet unsent requests. Only used with ptlrpcd now. */
605         struct list_head        set_new_requests;
606
607         /** rq_status of requests that have been freed already */
608         int                     set_rc;
609         /** Additional fields used by the flow control extension */
610         /** Maximum number of RPCs in flight */
611         int                     set_max_inflight;
612         /** Callback function used to generate RPCs */
613         set_producer_func       set_producer;
614         /** opaq argument passed to the producer callback */
615         void                    *set_producer_arg;
616         unsigned int             set_allow_intr:1;
617 };
618
619 struct ptlrpc_bulk_desc;
620 struct ptlrpc_service_part;
621 struct ptlrpc_service;
622
623 /**
624  * ptlrpc callback & work item stuff
625  */
626 struct ptlrpc_cb_id {
627         void (*cbid_fn)(struct lnet_event *ev); /* specific callback fn */
628         void *cbid_arg;                         /* additional arg */
629 };
630
631 /** Maximum number of locks to fit into reply state */
632 #define RS_MAX_LOCKS 8
633 #define RS_DEBUG     0
634
635 /**
636  * Structure to define reply state on the server
637  * Reply state holds various reply message information. Also for "difficult"
638  * replies (rep-ack case) we store the state after sending reply and wait
639  * for the client to acknowledge the reception. In these cases locks could be
640  * added to the state for replay/failover consistency guarantees.
641  */
642 struct ptlrpc_reply_state {
643         /** Callback description */
644         struct ptlrpc_cb_id     rs_cb_id;
645         /** Linkage for list of all reply states in a system */
646         struct list_head        rs_list;
647         /** Linkage for list of all reply states on same export */
648         struct list_head        rs_exp_list;
649         /** Linkage for list of all reply states for same obd */
650         struct list_head        rs_obd_list;
651 #if RS_DEBUG
652         struct list_head        rs_debug_list;
653 #endif
654         /** A spinlock to protect the reply state flags */
655         spinlock_t              rs_lock;
656         /** Reply state flags */
657         unsigned long          rs_difficult:1;     /* ACK/commit stuff */
658         unsigned long          rs_no_ack:1;    /* no ACK, even for
659                                                   difficult requests */
660         unsigned long          rs_scheduled:1;     /* being handled? */
661         unsigned long          rs_scheduled_ever:1;/* any schedule attempts? */
662         unsigned long          rs_handled:1;  /* been handled yet? */
663         unsigned long          rs_on_net:1;   /* reply_out_callback pending? */
664         unsigned long          rs_prealloc:1; /* rs from prealloc list */
665         unsigned long          rs_committed:1;/* the transaction was committed
666                                                  and the rs was dispatched
667                                                  by ptlrpc_commit_replies */
668         unsigned long           rs_convert_lock:1; /* need to convert saved
669                                                     * locks to COS mode */
670         atomic_t                rs_refcount;    /* number of users */
671         /** Number of locks awaiting client ACK */
672         int                     rs_nlocks;
673
674         /** Size of the state */
675         int                    rs_size;
676         /** opcode */
677         __u32                  rs_opc;
678         /** Transaction number */
679         __u64                  rs_transno;
680         /** xid */
681         __u64                  rs_xid;
682         struct obd_export     *rs_export;
683         struct ptlrpc_service_part *rs_svcpt;
684         /** Lnet metadata handle for the reply */
685         struct lnet_handle_md   rs_md_h;
686
687         /** Context for the sevice thread */
688         struct ptlrpc_svc_ctx   *rs_svc_ctx;
689         /** Reply buffer (actually sent to the client), encoded if needed */
690         struct lustre_msg       *rs_repbuf;     /* wrapper */
691         /** Size of the reply buffer */
692         int                     rs_repbuf_len;  /* wrapper buf length */
693         /** Size of the reply message */
694         int                     rs_repdata_len; /* wrapper msg length */
695         /**
696          * Actual reply message. Its content is encrupted (if needed) to
697          * produce reply buffer for actual sending. In simple case
698          * of no network encryption we jus set \a rs_repbuf to \a rs_msg
699          */
700         struct lustre_msg       *rs_msg;        /* reply message */
701
702         /** Handles of locks awaiting client reply ACK */
703         struct lustre_handle    rs_locks[RS_MAX_LOCKS];
704         /** Lock modes of locks in \a rs_locks */
705         enum ldlm_mode          rs_modes[RS_MAX_LOCKS];
706 };
707
708 struct ptlrpc_thread;
709
710 /** RPC stages */
711 enum rq_phase {
712         RQ_PHASE_NEW            = 0xebc0de00,
713         RQ_PHASE_RPC            = 0xebc0de01,
714         RQ_PHASE_BULK           = 0xebc0de02,
715         RQ_PHASE_INTERPRET      = 0xebc0de03,
716         RQ_PHASE_COMPLETE       = 0xebc0de04,
717         RQ_PHASE_UNREG_RPC      = 0xebc0de05,
718         RQ_PHASE_UNREG_BULK     = 0xebc0de06,
719         RQ_PHASE_UNDEFINED      = 0xebc0de07
720 };
721
722 /** Type of request interpreter call-back */
723 typedef int (*ptlrpc_interpterer_t)(const struct lu_env *env,
724                                     struct ptlrpc_request *req,
725                                     void *arg, int rc);
726 /** Type of request resend call-back */
727 typedef void (*ptlrpc_resend_cb_t)(struct ptlrpc_request *req,
728                                    void *arg);
729
730 /**
731  * Definition of request pool structure.
732  * The pool is used to store empty preallocated requests for the case
733  * when we would actually need to send something without performing
734  * any allocations (to avoid e.g. OOM).
735  */
736 struct ptlrpc_request_pool {
737         /** Locks the list */
738         spinlock_t              prp_lock;
739         /** list of ptlrpc_request structs */
740         struct list_head        prp_req_list;
741         /** Maximum message size that would fit into a rquest from this pool */
742         int                     prp_rq_size;
743         /** Function to allocate more requests for this pool */
744         int (*prp_populate)(struct ptlrpc_request_pool *, int);
745 };
746
747 struct lu_context;
748 struct lu_env;
749
750 struct ldlm_lock;
751
752 #include <lustre_nrs.h>
753
754 /**
755  * Basic request prioritization operations structure.
756  * The whole idea is centered around locks and RPCs that might affect locks.
757  * When a lock is contended we try to give priority to RPCs that might lead
758  * to fastest release of that lock.
759  * Currently only implemented for OSTs only in a way that makes all
760  * IO and truncate RPCs that are coming from a locked region where a lock is
761  * contended a priority over other requests.
762  */
763 struct ptlrpc_hpreq_ops {
764         /**
765          * Check if the lock handle of the given lock is the same as
766          * taken from the request.
767          */
768         int  (*hpreq_lock_match)(struct ptlrpc_request *, struct ldlm_lock *);
769         /**
770          * Check if the request is a high priority one.
771          */
772         int  (*hpreq_check)(struct ptlrpc_request *);
773         /**
774          * Called after the request has been handled.
775          */
776         void (*hpreq_fini)(struct ptlrpc_request *);
777 };
778
779 struct ptlrpc_cli_req {
780         /** For bulk requests on client only: bulk descriptor */
781         struct ptlrpc_bulk_desc         *cr_bulk;
782         /** optional time limit for send attempts. This is a timeout
783          *  not a timestamp so timeout_t (s32) is used instead of time64_t
784          */
785         timeout_t                        cr_delay_limit;
786         /** time request was first queued */
787         time64_t                         cr_queued_time;
788         /** request sent in nanoseconds */
789         ktime_t                          cr_sent_ns;
790         /** time for request really sent out */
791         time64_t                         cr_sent_out;
792         /** when req reply unlink must finish. */
793         time64_t                         cr_reply_deadline;
794         /** when req bulk unlink must finish. */
795         time64_t                         cr_bulk_deadline;
796         /** when req unlink must finish. */
797         time64_t                         cr_req_deadline;
798         /** Portal to which this request would be sent */
799         short                            cr_req_ptl;
800         /** Portal where to wait for reply and where reply would be sent */
801         short                            cr_rep_ptl;
802         /** request resending number */
803         unsigned int                     cr_resend_nr;
804         /** What was import generation when this request was sent */
805         int                              cr_imp_gen;
806         enum lustre_imp_state            cr_send_state;
807         /** Per-request waitq introduced by bug 21938 for recovery waiting */
808         wait_queue_head_t                cr_set_waitq;
809         /** Link item for request set lists */
810         struct list_head                 cr_set_chain;
811         /** link to waited ctx */
812         struct list_head                 cr_ctx_chain;
813
814         /** client's half ctx */
815         struct ptlrpc_cli_ctx           *cr_cli_ctx;
816         /** Link back to the request set */
817         struct ptlrpc_request_set       *cr_set;
818         /** outgoing request MD handle */
819         struct lnet_handle_md            cr_req_md_h;
820         /** request-out callback parameter */
821         struct ptlrpc_cb_id              cr_req_cbid;
822         /** incoming reply MD handle */
823         struct lnet_handle_md            cr_reply_md_h;
824         wait_queue_head_t                cr_reply_waitq;
825         /** reply callback parameter */
826         struct ptlrpc_cb_id              cr_reply_cbid;
827         /** Async completion handler, called when reply is received */
828         ptlrpc_interpterer_t             cr_reply_interp;
829         /** Resend handler, called when request is resend to update RPC data */
830         ptlrpc_resend_cb_t               cr_resend_cb;
831         /** Async completion context */
832         union ptlrpc_async_args          cr_async_args;
833         /** Opaq data for replay and commit callbacks. */
834         void                            *cr_cb_data;
835         /** Link to the imp->imp_unreplied_list */
836         struct list_head                 cr_unreplied_list;
837         /**
838          * Commit callback, called when request is committed and about to be
839          * freed.
840          */
841         void (*cr_commit_cb)(struct ptlrpc_request *);
842         /** Replay callback, called after request is replayed at recovery */
843         void (*cr_replay_cb)(struct ptlrpc_request *);
844 };
845
846 /** client request member alias */
847 /* NB: these alias should NOT be used by any new code, instead they should
848  * be removed step by step to avoid potential abuse */
849 #define rq_bulk                 rq_cli.cr_bulk
850 #define rq_delay_limit          rq_cli.cr_delay_limit
851 #define rq_queued_time          rq_cli.cr_queued_time
852 #define rq_sent_ns              rq_cli.cr_sent_ns
853 #define rq_real_sent            rq_cli.cr_sent_out
854 #define rq_reply_deadline       rq_cli.cr_reply_deadline
855 #define rq_bulk_deadline        rq_cli.cr_bulk_deadline
856 #define rq_req_deadline         rq_cli.cr_req_deadline
857 #define rq_nr_resend            rq_cli.cr_resend_nr
858 #define rq_request_portal       rq_cli.cr_req_ptl
859 #define rq_reply_portal         rq_cli.cr_rep_ptl
860 #define rq_import_generation    rq_cli.cr_imp_gen
861 #define rq_send_state           rq_cli.cr_send_state
862 #define rq_set_chain            rq_cli.cr_set_chain
863 #define rq_ctx_chain            rq_cli.cr_ctx_chain
864 #define rq_set                  rq_cli.cr_set
865 #define rq_set_waitq            rq_cli.cr_set_waitq
866 #define rq_cli_ctx              rq_cli.cr_cli_ctx
867 #define rq_req_md_h             rq_cli.cr_req_md_h
868 #define rq_req_cbid             rq_cli.cr_req_cbid
869 #define rq_reply_md_h           rq_cli.cr_reply_md_h
870 #define rq_reply_waitq          rq_cli.cr_reply_waitq
871 #define rq_reply_cbid           rq_cli.cr_reply_cbid
872 #define rq_interpret_reply      rq_cli.cr_reply_interp
873 #define rq_resend_cb            rq_cli.cr_resend_cb
874 #define rq_async_args           rq_cli.cr_async_args
875 #define rq_cb_data              rq_cli.cr_cb_data
876 #define rq_unreplied_list       rq_cli.cr_unreplied_list
877 #define rq_commit_cb            rq_cli.cr_commit_cb
878 #define rq_replay_cb            rq_cli.cr_replay_cb
879
880 struct ptlrpc_srv_req {
881         /** initial thread servicing this request */
882         struct ptlrpc_thread            *sr_svc_thread;
883         /**
884          * Server side list of incoming unserved requests sorted by arrival
885          * time.  Traversed from time to time to notice about to expire
886          * requests and sent back "early replies" to clients to let them
887          * know server is alive and well, just very busy to service their
888          * requests in time
889          */
890         struct list_head                 sr_timed_list;
891         /** server-side per-export list */
892         struct list_head                 sr_exp_list;
893         /** server-side history, used for debuging purposes. */
894         struct list_head                 sr_hist_list;
895         /** history sequence # */
896         __u64                            sr_hist_seq;
897         /** the index of service's srv_at_array into which request is linked */
898         __u32                            sr_at_index;
899         /** authed uid */
900         uid_t                            sr_auth_uid;
901         /** authed uid mapped to */
902         uid_t                            sr_auth_mapped_uid;
903         /** RPC is generated from what part of Lustre */
904         enum lustre_sec_part             sr_sp_from;
905         /** request session context */
906         struct lu_context                sr_ses;
907         /** \addtogroup  nrs
908          * @{
909          */
910         /** stub for NRS request */
911         struct ptlrpc_nrs_request        sr_nrq;
912         /** @} nrs */
913         /** request arrival time */
914         struct timespec64                sr_arrival_time;
915         /** server's half ctx */
916         struct ptlrpc_svc_ctx           *sr_svc_ctx;
917         /** (server side), pointed directly into req buffer */
918         struct ptlrpc_user_desc         *sr_user_desc;
919         /** separated reply state, may be vmalloc'd */
920         struct ptlrpc_reply_state       *sr_reply_state;
921         /** server-side hp handlers */
922         struct ptlrpc_hpreq_ops         *sr_ops;
923         /** incoming request buffer */
924         struct ptlrpc_request_buffer_desc *sr_rqbd;
925 };
926
927 /** server request member alias */
928 /* NB: these alias should NOT be used by any new code, instead they should
929  * be removed step by step to avoid potential abuse */
930 #define rq_svc_thread           rq_srv.sr_svc_thread
931 #define rq_timed_list           rq_srv.sr_timed_list
932 #define rq_exp_list             rq_srv.sr_exp_list
933 #define rq_history_list         rq_srv.sr_hist_list
934 #define rq_history_seq          rq_srv.sr_hist_seq
935 #define rq_at_index             rq_srv.sr_at_index
936 #define rq_auth_uid             rq_srv.sr_auth_uid
937 #define rq_auth_mapped_uid      rq_srv.sr_auth_mapped_uid
938 #define rq_sp_from              rq_srv.sr_sp_from
939 #define rq_session              rq_srv.sr_ses
940 #define rq_nrq                  rq_srv.sr_nrq
941 #define rq_arrival_time         rq_srv.sr_arrival_time
942 #define rq_reply_state          rq_srv.sr_reply_state
943 #define rq_svc_ctx              rq_srv.sr_svc_ctx
944 #define rq_user_desc            rq_srv.sr_user_desc
945 #define rq_ops                  rq_srv.sr_ops
946 #define rq_rqbd                 rq_srv.sr_rqbd
947
948 /**
949  * Represents remote procedure call.
950  *
951  * This is a staple structure used by everybody wanting to send a request
952  * in Lustre.
953  */
954 struct ptlrpc_request {
955         /* Request type: one of PTL_RPC_MSG_* */
956         int                              rq_type;
957         /** Result of request processing */
958         int                              rq_status;
959         /**
960          * Linkage item through which this request is included into
961          * sending/delayed lists on client and into rqbd list on server
962          */
963         struct list_head                 rq_list;
964         /** Lock to protect request flags and some other important bits, like
965          * rq_list
966          */
967         spinlock_t                       rq_lock;
968         spinlock_t                       rq_early_free_lock;
969         /** client-side flags are serialized by rq_lock @{ */
970         unsigned int rq_intr:1, rq_replied:1, rq_err:1,
971                 rq_timedout:1, rq_resend:1, rq_restart:1,
972                 /**
973                  * when ->rq_replay is set, request is kept by the client even
974                  * after server commits corresponding transaction. This is
975                  * used for operations that require sequence of multiple
976                  * requests to be replayed. The only example currently is file
977                  * open/close. When last request in such a sequence is
978                  * committed, ->rq_replay is cleared on all requests in the
979                  * sequence.
980                  */
981                 rq_replay:1,
982                 rq_no_resend:1, rq_waiting:1, rq_receiving_reply:1,
983                 rq_no_delay:1, rq_net_err:1, rq_wait_ctx:1,
984                 rq_early:1,
985                 rq_req_unlinked:1,      /* unlinked request buffer from lnet */
986                 rq_reply_unlinked:1,    /* unlinked reply buffer from lnet */
987                 rq_memalloc:1,      /* req originated from "kswapd" */
988                 rq_committed:1,
989                 rq_reply_truncated:1,
990                 /** whether the "rq_set" is a valid one */
991                 rq_invalid_rqset:1,
992                 rq_generation_set:1,
993                 /** do not resend request on -EINPROGRESS */
994                 rq_no_retry_einprogress:1,
995                 /* allow the req to be sent if the import is in recovery
996                  * status */
997                 rq_allow_replay:1,
998                 /* bulk request, sent to server, but uncommitted */
999                 rq_unstable:1,
1000                 rq_early_free_repbuf:1, /* free reply buffer in advance */
1001                 rq_allow_intr:1;
1002         /** @} */
1003
1004         /** server-side flags @{ */
1005         unsigned int
1006                 rq_hp:1,                /**< high priority RPC */
1007                 rq_at_linked:1,         /**< link into service's srv_at_array */
1008                 rq_packed_final:1,      /**< packed final reply */
1009                 rq_obsolete:1;          /* aborted by a signal on a client */
1010         /** @} */
1011
1012         /** one of RQ_PHASE_* */
1013         enum rq_phase                    rq_phase;
1014         /** one of RQ_PHASE_* to be used next */
1015         enum rq_phase                    rq_next_phase;
1016         /**
1017          * client-side refcount for SENT race, server-side refcounf
1018          * for multiple replies
1019          */
1020         atomic_t                         rq_refcount;
1021         /**
1022          * client-side:
1023          * !rq_truncate : # reply bytes actually received,
1024          *  rq_truncate : required repbuf_len for resend
1025          */
1026         int rq_nob_received;
1027         /** Request length */
1028         int rq_reqlen;
1029         /** Reply length */
1030         int rq_replen;
1031         /** Pool if request is from preallocated list */
1032         struct ptlrpc_request_pool      *rq_pool;
1033         /** Request message - what client sent */
1034         struct lustre_msg *rq_reqmsg;
1035         /** Reply message - server response */
1036         struct lustre_msg *rq_repmsg;
1037         /** Transaction number */
1038         __u64 rq_transno;
1039         /** xid */
1040         __u64                            rq_xid;
1041         /** bulk match bits */
1042         __u64                            rq_mbits;
1043         /**
1044          * List item to for replay list. Not yet committed requests get linked
1045          * there.
1046          * Also see \a rq_replay comment above.
1047          * It's also link chain on obd_export::exp_req_replay_queue
1048          */
1049         struct list_head                 rq_replay_list;
1050         /** non-shared members for client & server request*/
1051         union {
1052                 struct ptlrpc_cli_req    rq_cli;
1053                 struct ptlrpc_srv_req    rq_srv;
1054         };
1055         /**
1056          * security and encryption data
1057          * @{ */
1058         /** description of flavors for client & server */
1059         struct sptlrpc_flavor            rq_flvr;
1060
1061         /**
1062          * SELinux policy info at the time of the request
1063          * sepol string format is:
1064          * <mode>:<policy name>:<policy version>:<policy hash>
1065          */
1066         char rq_sepol[LUSTRE_NODEMAP_SEPOL_LENGTH + 1];
1067
1068         /* client/server security flags */
1069         unsigned int
1070                                  rq_ctx_init:1,      /* context initiation */
1071                                  rq_ctx_fini:1,      /* context destroy */
1072                                  rq_bulk_read:1,     /* request bulk read */
1073                                  rq_bulk_write:1,    /* request bulk write */
1074                                  /* server authentication flags */
1075                                  rq_auth_gss:1,      /* authenticated by gss */
1076                                  rq_auth_usr_root:1, /* authed as root */
1077                                  rq_auth_usr_mdt:1,  /* authed as mdt */
1078                                  rq_auth_usr_ost:1,  /* authed as ost */
1079                                  /* security tfm flags */
1080                                  rq_pack_udesc:1,
1081                                  rq_pack_bulk:1,
1082                                  /* doesn't expect reply FIXME */
1083                                  rq_no_reply:1,
1084                                  rq_pill_init:1, /* pill initialized */
1085                                  rq_srv_req:1; /* server request */
1086
1087
1088         /** various buffer pointers */
1089         struct lustre_msg               *rq_reqbuf;  /**< req wrapper, vmalloc*/
1090         char                            *rq_repbuf;  /**< rep buffer, vmalloc */
1091         struct lustre_msg               *rq_repdata; /**< rep wrapper msg */
1092         /** only in priv mode */
1093         struct lustre_msg               *rq_clrbuf;
1094         int                      rq_reqbuf_len;  /* req wrapper buf len */
1095         int                      rq_reqdata_len; /* req wrapper msg len */
1096         int                      rq_repbuf_len;  /* rep buffer len */
1097         int                      rq_repdata_len; /* rep wrapper msg len */
1098         int                      rq_clrbuf_len;  /* only in priv mode */
1099         int                      rq_clrdata_len; /* only in priv mode */
1100
1101         /** early replies go to offset 0, regular replies go after that */
1102         unsigned int                     rq_reply_off;
1103         /** @} */
1104
1105         /** Fields that help to see if request and reply were swabbed or not */
1106         __u32                            rq_req_swab_mask;
1107         __u32                            rq_rep_swab_mask;
1108
1109         /** how many early replies (for stats) */
1110         int                              rq_early_count;
1111         /** Server-side, export on which request was received */
1112         struct obd_export               *rq_export;
1113         /** import where request is being sent */
1114         struct obd_import               *rq_import;
1115         /** our LNet NID */
1116         lnet_nid_t                       rq_self;
1117         /** Peer description (the other side) */
1118         struct lnet_process_id           rq_peer;
1119         /** Descriptor for the NID from which the peer sent the request. */
1120         struct lnet_process_id           rq_source;
1121         /**
1122          * service time estimate (secs)
1123          * If the request is not served by this time, it is marked as timed out.
1124          * Do not change to time64_t since this is transmitted over the wire.
1125          *
1126          * The linux kernel handles timestamps with time64_t and timeouts
1127          * are normally done with jiffies. Lustre shares the rq_timeout between
1128          * nodes. Since jiffies can vary from node to node Lustre instead
1129          * will express the timeout value in seconds. To avoid confusion with
1130          * timestamps (time64_t) and jiffy timeouts (long) Lustre timeouts
1131          * are expressed in s32 (timeout_t). Also what is transmitted over
1132          * the wire is 32 bits.
1133          */
1134         timeout_t                        rq_timeout;
1135         /**
1136          * when request/reply sent (secs), or time when request should be sent
1137          */
1138         time64_t                         rq_sent;
1139         /** when request must finish. */
1140         time64_t                         rq_deadline;
1141         /** request format description */
1142         struct req_capsule               rq_pill;
1143 };
1144
1145 /**
1146  * Call completion handler for rpc if any, return it's status or original
1147  * rc if there was no handler defined for this request.
1148  */
1149 static inline int ptlrpc_req_interpret(const struct lu_env *env,
1150                                        struct ptlrpc_request *req, int rc)
1151 {
1152         if (req->rq_interpret_reply != NULL) {
1153                 req->rq_status = req->rq_interpret_reply(env, req,
1154                                                          &req->rq_async_args,
1155                                                          rc);
1156                 return req->rq_status;
1157         }
1158
1159         return rc;
1160 }
1161
1162 /** \addtogroup  nrs
1163  * @{
1164  */
1165 int ptlrpc_nrs_policy_register(struct ptlrpc_nrs_pol_conf *conf);
1166 int ptlrpc_nrs_policy_unregister(struct ptlrpc_nrs_pol_conf *conf);
1167 void ptlrpc_nrs_req_hp_move(struct ptlrpc_request *req);
1168 void nrs_policy_get_info_locked(struct ptlrpc_nrs_policy *policy,
1169                                 struct ptlrpc_nrs_pol_info *info);
1170
1171 /*
1172  * Can the request be moved from the regular NRS head to the high-priority NRS
1173  * head (of the same PTLRPC service partition), if any?
1174  *
1175  * For a reliable result, this should be checked under svcpt->scp_req lock.
1176  */
1177 static inline bool ptlrpc_nrs_req_can_move(struct ptlrpc_request *req)
1178 {
1179         struct ptlrpc_nrs_request *nrq = &req->rq_nrq;
1180
1181         /**
1182          * LU-898: Check ptlrpc_nrs_request::nr_enqueued to make sure the
1183          * request has been enqueued first, and ptlrpc_nrs_request::nr_started
1184          * to make sure it has not been scheduled yet (analogous to previous
1185          * (non-NRS) checking of !list_empty(&ptlrpc_request::rq_list).
1186          */
1187         return nrq->nr_enqueued && !nrq->nr_started && !req->rq_hp;
1188 }
1189 /** @} nrs */
1190
1191 /**
1192  * Returns true if request buffer at offset \a index was already swabbed
1193  */
1194 static inline bool lustre_req_swabbed(struct ptlrpc_request *req, size_t index)
1195 {
1196         LASSERT(index < sizeof(req->rq_req_swab_mask) * 8);
1197         return req->rq_req_swab_mask & BIT(index);
1198 }
1199
1200 /**
1201  * Returns true if request reply buffer at offset \a index was already swabbed
1202  */
1203 static inline bool lustre_rep_swabbed(struct ptlrpc_request *req, size_t index)
1204 {
1205         LASSERT(index < sizeof(req->rq_rep_swab_mask) * 8);
1206         return req->rq_rep_swab_mask & BIT(index);
1207 }
1208
1209 /**
1210  * Returns true if request needs to be swabbed into local cpu byteorder
1211  */
1212 static inline bool ptlrpc_req_need_swab(struct ptlrpc_request *req)
1213 {
1214         return lustre_req_swabbed(req, MSG_PTLRPC_HEADER_OFF);
1215 }
1216
1217 /**
1218  * Returns true if request reply needs to be swabbed into local cpu byteorder
1219  */
1220 static inline bool ptlrpc_rep_need_swab(struct ptlrpc_request *req)
1221 {
1222         return lustre_rep_swabbed(req, MSG_PTLRPC_HEADER_OFF);
1223 }
1224
1225 /**
1226  * Mark request buffer at offset \a index that it was already swabbed
1227  */
1228 static inline void lustre_set_req_swabbed(struct ptlrpc_request *req,
1229                                           size_t index)
1230 {
1231         LASSERT(index < sizeof(req->rq_req_swab_mask) * 8);
1232         LASSERT((req->rq_req_swab_mask & BIT(index)) == 0);
1233         req->rq_req_swab_mask |= BIT(index);
1234 }
1235
1236 /**
1237  * Mark request reply buffer at offset \a index that it was already swabbed
1238  */
1239 static inline void lustre_set_rep_swabbed(struct ptlrpc_request *req,
1240                                           size_t index)
1241 {
1242         LASSERT(index < sizeof(req->rq_rep_swab_mask) * 8);
1243         LASSERT((req->rq_rep_swab_mask & BIT(index)) == 0);
1244         req->rq_rep_swab_mask |= BIT(index);
1245 }
1246
1247 /**
1248  * Convert numerical request phase value \a phase into text string description
1249  */
1250 static inline const char *
1251 ptlrpc_phase2str(enum rq_phase phase)
1252 {
1253         switch (phase) {
1254         case RQ_PHASE_NEW:
1255                 return "New";
1256         case RQ_PHASE_RPC:
1257                 return "Rpc";
1258         case RQ_PHASE_BULK:
1259                 return "Bulk";
1260         case RQ_PHASE_INTERPRET:
1261                 return "Interpret";
1262         case RQ_PHASE_COMPLETE:
1263                 return "Complete";
1264         case RQ_PHASE_UNREG_RPC:
1265                 return "UnregRPC";
1266         case RQ_PHASE_UNREG_BULK:
1267                 return "UnregBULK";
1268         default:
1269                 return "?Phase?";
1270         }
1271 }
1272
1273 /**
1274  * Convert numerical request phase of the request \a req into text stringi
1275  * description
1276  */
1277 static inline const char *
1278 ptlrpc_rqphase2str(struct ptlrpc_request *req)
1279 {
1280         return ptlrpc_phase2str(req->rq_phase);
1281 }
1282
1283 /**
1284  * Debugging functions and helpers to print request structure into debug log
1285  * @{
1286  */
1287 /* Spare the preprocessor, spoil the bugs. */
1288 #define FLAG(field, str) (field ? str : "")
1289
1290 /** Convert bit flags into a string */
1291 #define DEBUG_REQ_FLAGS(req)                                                   \
1292         ptlrpc_rqphase2str(req),                                               \
1293         FLAG(req->rq_intr, "I"), FLAG(req->rq_replied, "R"),                   \
1294         FLAG(req->rq_err, "E"), FLAG(req->rq_net_err, "e"),                    \
1295         FLAG(req->rq_timedout, "X") /* eXpired */, FLAG(req->rq_resend, "S"),  \
1296         FLAG(req->rq_restart, "T"), FLAG(req->rq_replay, "P"),                 \
1297         FLAG(req->rq_no_resend, "N"), FLAG(req->rq_no_reply, "n"),            \
1298         FLAG(req->rq_waiting, "W"),                                            \
1299         FLAG(req->rq_wait_ctx, "C"), FLAG(req->rq_hp, "H"),                    \
1300         FLAG(req->rq_committed, "M"),                                          \
1301         FLAG(req->rq_req_unlinked, "Q"),                                       \
1302         FLAG(req->rq_reply_unlinked, "U"),                                     \
1303         FLAG(req->rq_receiving_reply, "r")
1304
1305 #define REQ_FLAGS_FMT "%s:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
1306
1307 void _debug_req(struct ptlrpc_request *req,
1308                 struct libcfs_debug_msg_data *data, const char *fmt, ...)
1309         __attribute__ ((format (printf, 3, 4)));
1310
1311 /**
1312  * Helper that decides if we need to print request accordig to current debug
1313  * level settings
1314  */
1315 #define debug_req(msgdata, mask, cdls, req, fmt, a...)                        \
1316 do {                                                                          \
1317         CFS_CHECK_STACK(msgdata, mask, cdls);                                 \
1318                                                                               \
1319         if (((mask) & D_CANTMASK) != 0 ||                                     \
1320             ((libcfs_debug & (mask)) != 0 &&                                  \
1321              (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0))                \
1322                 _debug_req((req), msgdata, fmt, ##a);                         \
1323 } while(0)
1324
1325 /**
1326  * This is the debug print function you need to use to print request sturucture
1327  * content into lustre debug log.
1328  * for most callers (level is a constant) this is resolved at compile time */
1329 #define DEBUG_REQ(level, req, fmt, args...)                                   \
1330 do {                                                                          \
1331         if ((level) & (D_ERROR | D_WARNING)) {                                \
1332                 static struct cfs_debug_limit_state cdls;                     \
1333                 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, level, &cdls);            \
1334                 debug_req(&msgdata, level, &cdls, req, "@@@ "fmt" ", ## args);\
1335         } else {                                                              \
1336                 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, level, NULL);             \
1337                 debug_req(&msgdata, level, NULL, req, "@@@ "fmt" ", ## args); \
1338         }                                                                     \
1339 } while (0)
1340 /** @} */
1341
1342 enum ptlrpc_bulk_op_type {
1343         PTLRPC_BULK_OP_ACTIVE =  0x00000001,
1344         PTLRPC_BULK_OP_PASSIVE = 0x00000002,
1345         PTLRPC_BULK_OP_PUT =     0x00000004,
1346         PTLRPC_BULK_OP_GET =     0x00000008,
1347         PTLRPC_BULK_GET_SOURCE = PTLRPC_BULK_OP_PASSIVE | PTLRPC_BULK_OP_GET,
1348         PTLRPC_BULK_PUT_SINK =   PTLRPC_BULK_OP_PASSIVE | PTLRPC_BULK_OP_PUT,
1349         PTLRPC_BULK_GET_SINK =   PTLRPC_BULK_OP_ACTIVE | PTLRPC_BULK_OP_GET,
1350         PTLRPC_BULK_PUT_SOURCE = PTLRPC_BULK_OP_ACTIVE | PTLRPC_BULK_OP_PUT,
1351 };
1352
1353 static inline bool ptlrpc_is_bulk_op_get(enum ptlrpc_bulk_op_type type)
1354 {
1355         return (type & PTLRPC_BULK_OP_GET) == PTLRPC_BULK_OP_GET;
1356 }
1357
1358 static inline bool ptlrpc_is_bulk_get_source(enum ptlrpc_bulk_op_type type)
1359 {
1360         return (type & PTLRPC_BULK_GET_SOURCE) == PTLRPC_BULK_GET_SOURCE;
1361 }
1362
1363 static inline bool ptlrpc_is_bulk_put_sink(enum ptlrpc_bulk_op_type type)
1364 {
1365         return (type & PTLRPC_BULK_PUT_SINK) == PTLRPC_BULK_PUT_SINK;
1366 }
1367
1368 static inline bool ptlrpc_is_bulk_get_sink(enum ptlrpc_bulk_op_type type)
1369 {
1370         return (type & PTLRPC_BULK_GET_SINK) == PTLRPC_BULK_GET_SINK;
1371 }
1372
1373 static inline bool ptlrpc_is_bulk_put_source(enum ptlrpc_bulk_op_type type)
1374 {
1375         return (type & PTLRPC_BULK_PUT_SOURCE) == PTLRPC_BULK_PUT_SOURCE;
1376 }
1377
1378 static inline bool ptlrpc_is_bulk_op_active(enum ptlrpc_bulk_op_type type)
1379 {
1380         return ((type & PTLRPC_BULK_OP_ACTIVE) |
1381                 (type & PTLRPC_BULK_OP_PASSIVE))
1382                         == PTLRPC_BULK_OP_ACTIVE;
1383 }
1384
1385 static inline bool ptlrpc_is_bulk_op_passive(enum ptlrpc_bulk_op_type type)
1386 {
1387         return ((type & PTLRPC_BULK_OP_ACTIVE) |
1388                 (type & PTLRPC_BULK_OP_PASSIVE))
1389                         == PTLRPC_BULK_OP_PASSIVE;
1390 }
1391
1392 struct ptlrpc_bulk_frag_ops {
1393         /**
1394          * Add a page \a page to the bulk descriptor \a desc
1395          * Data to transfer in the page starts at offset \a pageoffset and
1396          * amount of data to transfer from the page is \a len
1397          */
1398         void (*add_kiov_frag)(struct ptlrpc_bulk_desc *desc,
1399                               struct page *page, int pageoffset, int len);
1400
1401         /*
1402          * Add a \a fragment to the bulk descriptor \a desc.
1403          * Data to transfer in the fragment is pointed to by \a frag
1404          * The size of the fragment is \a len
1405          */
1406         int (*add_iov_frag)(struct ptlrpc_bulk_desc *desc, void *frag, int len);
1407
1408         /**
1409          * Uninitialize and free bulk descriptor \a desc.
1410          * Works on bulk descriptors both from server and client side.
1411          */
1412         void (*release_frags)(struct ptlrpc_bulk_desc *desc);
1413 };
1414
1415 extern const struct ptlrpc_bulk_frag_ops ptlrpc_bulk_kiov_pin_ops;
1416 extern const struct ptlrpc_bulk_frag_ops ptlrpc_bulk_kiov_nopin_ops;
1417
1418 /*
1419  * Definition of bulk descriptor.
1420  * Bulks are special "Two phase" RPCs where initial request message
1421  * is sent first and it is followed bt a transfer (o receiving) of a large
1422  * amount of data to be settled into pages referenced from the bulk descriptors.
1423  * Bulks transfers (the actual data following the small requests) are done
1424  * on separate LNet portals.
1425  * In lustre we use bulk transfers for READ and WRITE transfers from/to OSTs.
1426  *  Another user is readpage for MDT.
1427  */
1428 struct ptlrpc_bulk_desc {
1429         unsigned int    bd_refs; /* number MD's assigned including zero-sends */
1430         /** completed with failure */
1431         unsigned long bd_failure:1;
1432         /** client side */
1433         unsigned long bd_registered:1;
1434         /** For serialization with callback */
1435         spinlock_t bd_lock;
1436         /** {put,get}{source,sink}{kvec,kiov} */
1437         enum ptlrpc_bulk_op_type bd_type;
1438         /** LNet portal for this bulk */
1439         __u32 bd_portal;
1440         /** Server side - export this bulk created for */
1441         struct obd_export *bd_export;
1442         /** Client side - import this bulk was sent on */
1443         struct obd_import *bd_import;
1444         /** Back pointer to the request */
1445         struct ptlrpc_request *bd_req;
1446         const struct ptlrpc_bulk_frag_ops *bd_frag_ops;
1447         wait_queue_head_t      bd_waitq;        /* server side only WQ */
1448         int                    bd_iov_count;    /* # entries in bd_iov */
1449         int                    bd_max_iov;      /* allocated size of bd_iov */
1450         int                    bd_nob;          /* # bytes covered */
1451         int                    bd_nob_transferred; /* # bytes GOT/PUT */
1452         unsigned int            bd_nob_last;    /* # bytes in last MD */
1453
1454         __u64                  bd_last_mbits;
1455
1456         struct ptlrpc_cb_id    bd_cbid;         /* network callback info */
1457         lnet_nid_t             bd_sender;       /* stash event::sender */
1458         int                     bd_md_count;    /* # valid entries in bd_mds */
1459         int                     bd_md_max_brw;  /* max entries in bd_mds */
1460
1461         /** array of offsets for each MD */
1462         unsigned int            bd_mds_off[PTLRPC_BULK_OPS_COUNT];
1463         /** array of associated MDs */
1464         struct lnet_handle_md   bd_mds[PTLRPC_BULK_OPS_COUNT];
1465
1466         /* encrypted iov, size is either 0 or bd_iov_count. */
1467         struct bio_vec *bd_enc_vec;
1468         struct bio_vec *bd_vec;
1469 };
1470
1471 enum {
1472         SVC_INIT        = 0,
1473         SVC_STOPPED     = BIT(0),
1474         SVC_STOPPING    = BIT(1),
1475         SVC_STARTING    = BIT(2),
1476         SVC_RUNNING     = BIT(3),
1477 };
1478
1479 #define PTLRPC_THR_NAME_LEN             32
1480 /**
1481  * Definition of server service thread structure
1482  */
1483 struct ptlrpc_thread {
1484         /**
1485          * List of active threads in svcpt->scp_threads
1486          */
1487         struct list_head t_link;
1488         /**
1489          * thread-private data (preallocated vmalloc'd memory)
1490          */
1491         void *t_data;
1492         __u32 t_flags;
1493         /**
1494          * service thread index, from ptlrpc_start_threads
1495          */
1496         unsigned int t_id;
1497         /**
1498          * service thread
1499          */
1500         struct task_struct *t_task;
1501         pid_t t_pid;
1502         ktime_t t_touched;
1503         /**
1504          * put watchdog in the structure per thread b=14840
1505          */
1506         struct delayed_work t_watchdog;
1507         /**
1508          * the svc this thread belonged to b=18582
1509          */
1510         struct ptlrpc_service_part      *t_svcpt;
1511         wait_queue_head_t               t_ctl_waitq;
1512         struct lu_env                   *t_env;
1513         char                            t_name[PTLRPC_THR_NAME_LEN];
1514 };
1515
1516 static inline int thread_is_init(struct ptlrpc_thread *thread)
1517 {
1518         return thread->t_flags == 0;
1519 }
1520
1521 static inline int thread_is_stopped(struct ptlrpc_thread *thread)
1522 {
1523         return !!(thread->t_flags & SVC_STOPPED);
1524 }
1525
1526 static inline int thread_is_stopping(struct ptlrpc_thread *thread)
1527 {
1528         return !!(thread->t_flags & SVC_STOPPING);
1529 }
1530
1531 static inline int thread_is_starting(struct ptlrpc_thread *thread)
1532 {
1533         return !!(thread->t_flags & SVC_STARTING);
1534 }
1535
1536 static inline int thread_is_running(struct ptlrpc_thread *thread)
1537 {
1538         return !!(thread->t_flags & SVC_RUNNING);
1539 }
1540
1541 static inline void thread_clear_flags(struct ptlrpc_thread *thread, __u32 flags)
1542 {
1543         thread->t_flags &= ~flags;
1544 }
1545
1546 static inline void thread_set_flags(struct ptlrpc_thread *thread, __u32 flags)
1547 {
1548         thread->t_flags = flags;
1549 }
1550
1551 static inline void thread_add_flags(struct ptlrpc_thread *thread, __u32 flags)
1552 {
1553         thread->t_flags |= flags;
1554 }
1555
1556 static inline int thread_test_and_clear_flags(struct ptlrpc_thread *thread,
1557                                               __u32 flags)
1558 {
1559         if (thread->t_flags & flags) {
1560                 thread->t_flags &= ~flags;
1561                 return 1;
1562         }
1563         return 0;
1564 }
1565
1566 /**
1567  * Request buffer descriptor structure.
1568  * This is a structure that contains one posted request buffer for service.
1569  * Once data land into a buffer, event callback creates actual request and
1570  * notifies wakes one of the service threads to process new incoming request.
1571  * More than one request can fit into the buffer.
1572  */
1573 struct ptlrpc_request_buffer_desc {
1574         /** Link item for rqbds on a service */
1575         struct list_head                rqbd_list;
1576         /** History of requests for this buffer */
1577         struct list_head                rqbd_reqs;
1578         /** Back pointer to service for which this buffer is registered */
1579         struct ptlrpc_service_part      *rqbd_svcpt;
1580         /** LNet descriptor */
1581         struct lnet_handle_md           rqbd_md_h;
1582         int                             rqbd_refcount;
1583         /** The buffer itself */
1584         char                            *rqbd_buffer;
1585         struct ptlrpc_cb_id             rqbd_cbid;
1586         /**
1587          * This "embedded" request structure is only used for the
1588          * last request to fit into the buffer
1589          */
1590         struct ptlrpc_request           rqbd_req;
1591 };
1592
1593 typedef int  (*svc_handler_t)(struct ptlrpc_request *req);
1594
1595 struct ptlrpc_service_ops {
1596         /**
1597          * if non-NULL called during thread creation (ptlrpc_start_thread())
1598          * to initialize service specific per-thread state.
1599          */
1600         int             (*so_thr_init)(struct ptlrpc_thread *thr);
1601         /**
1602          * if non-NULL called during thread shutdown (ptlrpc_main()) to
1603          * destruct state created by ->srv_init().
1604          */
1605         void            (*so_thr_done)(struct ptlrpc_thread *thr);
1606         /**
1607          * Handler function for incoming requests for this service
1608          */
1609         int             (*so_req_handler)(struct ptlrpc_request *req);
1610         /**
1611          * function to determine priority of the request, it's called
1612          * on every new request
1613          */
1614         int             (*so_hpreq_handler)(struct ptlrpc_request *);
1615         /**
1616          * service-specific print fn
1617          */
1618         void            (*so_req_printer)(void *, struct ptlrpc_request *);
1619 };
1620
1621 #ifndef __cfs_cacheline_aligned
1622 /* NB: put it here for reducing patche dependence */
1623 # define __cfs_cacheline_aligned
1624 #endif
1625
1626 /**
1627  * How many high priority requests to serve before serving one normal
1628  * priority request
1629  */
1630 #define PTLRPC_SVC_HP_RATIO 10
1631
1632 /**
1633  * Definition of PortalRPC service.
1634  * The service is listening on a particular portal (like tcp port)
1635  * and perform actions for a specific server like IO service for OST
1636  * or general metadata service for MDS.
1637  */
1638 struct ptlrpc_service {
1639         /** serialize /proc operations */
1640         spinlock_t                      srv_lock;
1641         /** most often accessed fields */
1642         /** chain thru all services */
1643         struct list_head                srv_list;
1644         /** service operations table */
1645         struct ptlrpc_service_ops       srv_ops;
1646         /** only statically allocated strings here; we don't clean them */
1647         char                           *srv_name;
1648         /** only statically allocated strings here; we don't clean them */
1649         char                           *srv_thread_name;
1650         /** threads # should be created for each partition on initializing */
1651         int                             srv_nthrs_cpt_init;
1652         /** limit of threads number for each partition */
1653         int                             srv_nthrs_cpt_limit;
1654         /** Root of debugfs dir tree for this service */
1655         struct dentry                  *srv_debugfs_entry;
1656         /** Pointer to statistic data for this service */
1657         struct lprocfs_stats           *srv_stats;
1658         /** # hp per lp reqs to handle */
1659         int                             srv_hpreq_ratio;
1660         /** biggest request to receive */
1661         int                             srv_max_req_size;
1662         /** biggest reply to send */
1663         int                             srv_max_reply_size;
1664         /** size of individual buffers */
1665         int                             srv_buf_size;
1666         /** # buffers to allocate in 1 group */
1667         int                             srv_nbuf_per_group;
1668         /** Local portal on which to receive requests */
1669         __u32                           srv_req_portal;
1670         /** Portal on the client to send replies to */
1671         __u32                           srv_rep_portal;
1672         /**
1673          * Tags for lu_context associated with this thread, see struct
1674          * lu_context.
1675          */
1676         __u32                           srv_ctx_tags;
1677         /** soft watchdog timeout multiplier */
1678         int                             srv_watchdog_factor;
1679         /** under unregister_service */
1680         unsigned                        srv_is_stopping:1;
1681         /** Whether or not to restrict service threads to CPUs in this CPT */
1682         unsigned                        srv_cpt_bind:1;
1683
1684         /** max # request buffers */
1685         int                             srv_nrqbds_max;
1686         /** max # request buffers in history per partition */
1687         int                             srv_hist_nrqbds_cpt_max;
1688         /** number of CPTs this service associated with */
1689         int                             srv_ncpts;
1690         /** CPTs array this service associated with */
1691         __u32                           *srv_cpts;
1692         /** 2^srv_cptab_bits >= cfs_cpt_numbert(srv_cptable) */
1693         int                             srv_cpt_bits;
1694         /** CPT table this service is running over */
1695         struct cfs_cpt_table            *srv_cptable;
1696
1697         /* sysfs object */
1698         struct kobject                  srv_kobj;
1699         struct completion               srv_kobj_unregister;
1700         /**
1701          * partition data for ptlrpc service
1702          */
1703         struct ptlrpc_service_part      *srv_parts[0];
1704 };
1705
1706 /**
1707  * Definition of PortalRPC service partition data.
1708  * Although a service only has one instance of it right now, but we
1709  * will have multiple instances very soon (instance per CPT).
1710  *
1711  * it has four locks:
1712  * \a scp_lock
1713  *    serialize operations on rqbd and requests waiting for preprocess
1714  * \a scp_req_lock
1715  *    serialize operations active requests sent to this portal
1716  * \a scp_at_lock
1717  *    serialize adaptive timeout stuff
1718  * \a scp_rep_lock
1719  *    serialize operations on RS list (reply states)
1720  *
1721  * We don't have any use-case to take two or more locks at the same time
1722  * for now, so there is no lock order issue.
1723  */
1724 struct ptlrpc_service_part {
1725         /** back reference to owner */
1726         struct ptlrpc_service           *scp_service __cfs_cacheline_aligned;
1727         /* CPT id, reserved */
1728         int                             scp_cpt;
1729         /** always increasing number */
1730         int                             scp_thr_nextid;
1731         /** # of starting threads */
1732         int                             scp_nthrs_starting;
1733         /** # running threads */
1734         int                             scp_nthrs_running;
1735         /** service threads list */
1736         struct list_head                scp_threads;
1737
1738         /**
1739          * serialize the following fields, used for protecting
1740          * rqbd list and incoming requests waiting for preprocess,
1741          * threads starting & stopping are also protected by this lock.
1742          */
1743         spinlock_t                      scp_lock  __cfs_cacheline_aligned;
1744         /** userland serialization */
1745         struct mutex                    scp_mutex;
1746         /** total # req buffer descs allocated */
1747         int                             scp_nrqbds_total;
1748         /** # posted request buffers for receiving */
1749         int                             scp_nrqbds_posted;
1750         /** in progress of allocating rqbd */
1751         int                             scp_rqbd_allocating;
1752         /** # incoming reqs */
1753         int                             scp_nreqs_incoming;
1754         /** request buffers to be reposted */
1755         struct list_head                scp_rqbd_idle;
1756         /** req buffers receiving */
1757         struct list_head                scp_rqbd_posted;
1758         /** incoming reqs */
1759         struct list_head                scp_req_incoming;
1760         /** timeout before re-posting reqs, in jiffies */
1761         long                            scp_rqbd_timeout;
1762         /**
1763          * all threads sleep on this. This wait-queue is signalled when new
1764          * incoming request arrives and when difficult reply has to be handled.
1765          */
1766         wait_queue_head_t               scp_waitq;
1767
1768         /** request history */
1769         struct list_head                scp_hist_reqs;
1770         /** request buffer history */
1771         struct list_head                scp_hist_rqbds;
1772         /** # request buffers in history */
1773         int                             scp_hist_nrqbds;
1774         /** sequence number for request */
1775         __u64                           scp_hist_seq;
1776         /** highest seq culled from history */
1777         __u64                           scp_hist_seq_culled;
1778
1779         /**
1780          * serialize the following fields, used for processing requests
1781          * sent to this portal
1782          */
1783         spinlock_t                      scp_req_lock __cfs_cacheline_aligned;
1784         /** # reqs in either of the NRS heads below */
1785         /** # reqs being served */
1786         int                             scp_nreqs_active;
1787         /** # HPreqs being served */
1788         int                             scp_nhreqs_active;
1789         /** # hp requests handled */
1790         int                             scp_hreq_count;
1791
1792         /** NRS head for regular requests */
1793         struct ptlrpc_nrs               scp_nrs_reg;
1794         /** NRS head for HP requests; this is only valid for services that can
1795          *  handle HP requests */
1796         struct ptlrpc_nrs              *scp_nrs_hp;
1797
1798         /** AT stuff */
1799         /** @{ */
1800         /**
1801          * serialize the following fields, used for changes on
1802          * adaptive timeout
1803          */
1804         spinlock_t                      scp_at_lock __cfs_cacheline_aligned;
1805         /** estimated rpc service time */
1806         struct adaptive_timeout         scp_at_estimate;
1807         /** reqs waiting for replies */
1808         struct ptlrpc_at_array          scp_at_array;
1809         /** early reply timer */
1810         struct timer_list               scp_at_timer;
1811         /** debug */
1812         ktime_t                         scp_at_checktime;
1813         /** check early replies */
1814         unsigned                        scp_at_check;
1815         /** @} */
1816
1817         /**
1818          * serialize the following fields, used for processing
1819          * replies for this portal
1820          */
1821         spinlock_t                      scp_rep_lock __cfs_cacheline_aligned;
1822         /** all the active replies */
1823         struct list_head                scp_rep_active;
1824         /** List of free reply_states */
1825         struct list_head                scp_rep_idle;
1826         /** waitq to run, when adding stuff to srv_free_rs_list */
1827         wait_queue_head_t               scp_rep_waitq;
1828         /** # 'difficult' replies */
1829         atomic_t                        scp_nreps_difficult;
1830 };
1831
1832 #define ptlrpc_service_for_each_part(part, i, svc)                      \
1833         for (i = 0;                                                     \
1834              i < (svc)->srv_ncpts &&                                    \
1835              (svc)->srv_parts != NULL &&                                \
1836              ((part) = (svc)->srv_parts[i]) != NULL; i++)
1837
1838 /**
1839  * Declaration of ptlrpcd control structure
1840  */
1841 struct ptlrpcd_ctl {
1842         /**
1843          * Ptlrpc thread control flags (LIOD_START, LIOD_STOP, LIOD_FORCE)
1844          */
1845         unsigned long                   pc_flags;
1846         /**
1847          * Thread lock protecting structure fields.
1848          */
1849         spinlock_t                      pc_lock;
1850         /**
1851          * Start completion.
1852          */
1853         struct completion               pc_starting;
1854         /**
1855          * Stop completion.
1856          */
1857         struct completion               pc_finishing;
1858         /**
1859          * Thread requests set.
1860          */
1861         struct ptlrpc_request_set       *pc_set;
1862         /**
1863          * Thread name used in kthread_run()
1864          */
1865         char                            pc_name[16];
1866         /**
1867          * CPT the thread is bound on.
1868          */
1869         int                             pc_cpt;
1870         /**
1871          * Index of ptlrpcd thread in the array.
1872          */
1873         int                             pc_index;
1874         /**
1875          * Pointer to the array of partners' ptlrpcd_ctl structure.
1876          */
1877         struct ptlrpcd_ctl              **pc_partners;
1878         /**
1879          * Number of the ptlrpcd's partners.
1880          */
1881         int                             pc_npartners;
1882         /**
1883          * Record the partner index to be processed next.
1884          */
1885         int                             pc_cursor;
1886         /**
1887          * Error code if the thread failed to fully start.
1888          */
1889         int                             pc_error;
1890 };
1891
1892 /* Bits for pc_flags */
1893 enum ptlrpcd_ctl_flags {
1894         /**
1895          * Ptlrpc thread start flag.
1896          */
1897         LIOD_START      = BIT(0),
1898         /**
1899          * Ptlrpc thread stop flag.
1900          */
1901         LIOD_STOP       = BIT(1),
1902         /**
1903          * Ptlrpc thread force flag (only stop force so far).
1904          * This will cause aborting any inflight rpcs handled
1905          * by thread if LIOD_STOP is specified.
1906          */
1907         LIOD_FORCE      = BIT(2),
1908         /**
1909          * This is a recovery ptlrpc thread.
1910          */
1911         LIOD_RECOVERY   = BIT(3),
1912 };
1913
1914 /**
1915  * \addtogroup nrs
1916  * @{
1917  *
1918  * Service compatibility function; the policy is compatible with all services.
1919  *
1920  * \param[in] svc  The service the policy is attempting to register with.
1921  * \param[in] desc The policy descriptor
1922  *
1923  * \retval true The policy is compatible with the service
1924  *
1925  * \see ptlrpc_nrs_pol_desc::pd_compat()
1926  */
1927 static inline bool nrs_policy_compat_all(const struct ptlrpc_service *svc,
1928                                          const struct ptlrpc_nrs_pol_desc *desc)
1929 {
1930         return true;
1931 }
1932
1933 /**
1934  * Service compatibility function; the policy is compatible with only a specific
1935  * service which is identified by its human-readable name at
1936  * ptlrpc_service::srv_name.
1937  *
1938  * \param[in] svc  The service the policy is attempting to register with.
1939  * \param[in] desc The policy descriptor
1940  *
1941  * \retval false The policy is not compatible with the service
1942  * \retval true  The policy is compatible with the service
1943  *
1944  * \see ptlrpc_nrs_pol_desc::pd_compat()
1945  */
1946 static inline bool nrs_policy_compat_one(const struct ptlrpc_service *svc,
1947                                          const struct ptlrpc_nrs_pol_desc *desc)
1948 {
1949         LASSERT(desc->pd_compat_svc_name != NULL);
1950         return strcmp(svc->srv_name, desc->pd_compat_svc_name) == 0;
1951 }
1952
1953 /** @} nrs */
1954
1955 /* ptlrpc/events.c */
1956 extern int ptlrpc_uuid_to_peer(struct obd_uuid *uuid,
1957                                struct lnet_process_id *peer, lnet_nid_t *self);
1958 /**
1959  * These callbacks are invoked by LNet when something happened to
1960  * underlying buffer
1961  * @{
1962  */
1963 extern void request_out_callback(struct lnet_event *ev);
1964 extern void reply_in_callback(struct lnet_event *ev);
1965 extern void client_bulk_callback(struct lnet_event *ev);
1966 extern void request_in_callback(struct lnet_event *ev);
1967 extern void reply_out_callback(struct lnet_event *ev);
1968 #ifdef HAVE_SERVER_SUPPORT
1969 extern void server_bulk_callback(struct lnet_event *ev);
1970 #endif
1971 /** @} */
1972
1973 /* ptlrpc/connection.c */
1974 struct ptlrpc_connection *ptlrpc_connection_get(struct lnet_process_id peer,
1975                                                 lnet_nid_t self,
1976                                                 struct obd_uuid *uuid);
1977 int ptlrpc_connection_put(struct ptlrpc_connection *c);
1978 struct ptlrpc_connection *ptlrpc_connection_addref(struct ptlrpc_connection *);
1979 int ptlrpc_connection_init(void);
1980 void ptlrpc_connection_fini(void);
1981 extern lnet_pid_t ptl_get_pid(void);
1982
1983 /*
1984  * Check if the peer connection is on the local node.  We need to use GFP_NOFS
1985  * for requests from a local client to avoid recursing into the filesystem
1986  * as we might end up waiting on a page sent in the request we're serving.
1987  *
1988  * Use __GFP_HIGHMEM so that the pages can use all of the available memory
1989  * on 32-bit machines.  Use more aggressive GFP_HIGHUSER flags from non-local
1990  * clients to be able to generate more memory pressure on the OSS and allow
1991  * inactive pages to be reclaimed, since it doesn't have any other processes
1992  * or allocations that generate memory reclaim pressure.
1993  *
1994  * See b=17576 (bdf50dc9) and b=19529 (3dcf18d3) for details.
1995  */
1996 static inline bool ptlrpc_connection_is_local(struct ptlrpc_connection *conn)
1997 {
1998         if (!conn)
1999                 return false;
2000
2001         if (conn->c_peer.nid == conn->c_self)
2002                 return true;
2003
2004         RETURN(LNetIsPeerLocal(conn->c_peer.nid));
2005 }
2006
2007 /* ptlrpc/niobuf.c */
2008 /**
2009  * Actual interfacing with LNet to put/get/register/unregister stuff
2010  * @{
2011  */
2012 #ifdef HAVE_SERVER_SUPPORT
2013 struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req,
2014                                               unsigned nfrags, unsigned max_brw,
2015                                               unsigned int type,
2016                                               unsigned portal,
2017                                               const struct ptlrpc_bulk_frag_ops
2018                                                 *ops);
2019 int ptlrpc_start_bulk_transfer(struct ptlrpc_bulk_desc *desc);
2020 void ptlrpc_abort_bulk(struct ptlrpc_bulk_desc *desc);
2021
2022 static inline int ptlrpc_server_bulk_active(struct ptlrpc_bulk_desc *desc)
2023 {
2024         int rc;
2025
2026         LASSERT(desc != NULL);
2027
2028         spin_lock(&desc->bd_lock);
2029         rc = desc->bd_refs;
2030         spin_unlock(&desc->bd_lock);
2031         return rc;
2032 }
2033 #endif
2034
2035 int ptlrpc_register_bulk(struct ptlrpc_request *req);
2036 int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async);
2037
2038 static inline int ptlrpc_client_bulk_active(struct ptlrpc_request *req)
2039 {
2040         struct ptlrpc_bulk_desc *desc;
2041         int rc;
2042
2043         LASSERT(req != NULL);
2044         desc = req->rq_bulk;
2045
2046         if (!desc)
2047                 return 0;
2048
2049         if (req->rq_bulk_deadline > ktime_get_real_seconds())
2050                 return 1;
2051
2052
2053         spin_lock(&desc->bd_lock);
2054         rc = desc->bd_refs;
2055         spin_unlock(&desc->bd_lock);
2056         return rc;
2057 }
2058
2059 #define PTLRPC_REPLY_MAYBE_DIFFICULT 0x01
2060 #define PTLRPC_REPLY_EARLY           0x02
2061 int ptlrpc_send_reply(struct ptlrpc_request *req, int flags);
2062 int ptlrpc_reply(struct ptlrpc_request *req);
2063 int ptlrpc_send_error(struct ptlrpc_request *req, int difficult);
2064 int ptlrpc_error(struct ptlrpc_request *req);
2065 int ptlrpc_at_get_net_latency(struct ptlrpc_request *req);
2066 int ptl_send_rpc(struct ptlrpc_request *request, int noreply);
2067 int ptlrpc_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd);
2068 /** @} */
2069
2070 /* ptlrpc/client.c */
2071 /**
2072  * Client-side portals API. Everything to send requests, receive replies,
2073  * request queues, request management, etc.
2074  * @{
2075  */
2076 void ptlrpc_request_committed(struct ptlrpc_request *req, int force);
2077
2078 void ptlrpc_init_client(int req_portal, int rep_portal, const char *name,
2079                         struct ptlrpc_client *);
2080 void ptlrpc_cleanup_client(struct obd_import *imp);
2081 struct ptlrpc_connection *ptlrpc_uuid_to_connection(struct obd_uuid *uuid,
2082                                                     lnet_nid_t nid4refnet);
2083
2084 int ptlrpc_queue_wait(struct ptlrpc_request *req);
2085 int ptlrpc_replay_req(struct ptlrpc_request *req);
2086 void ptlrpc_restart_req(struct ptlrpc_request *req);
2087 void ptlrpc_abort_inflight(struct obd_import *imp);
2088 void ptlrpc_cleanup_imp(struct obd_import *imp);
2089 void ptlrpc_abort_set(struct ptlrpc_request_set *set);
2090
2091 struct ptlrpc_request_set *ptlrpc_prep_set(void);
2092 struct ptlrpc_request_set *ptlrpc_prep_fcset(int max, set_producer_func func,
2093                                              void *arg);
2094 int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set);
2095 int ptlrpc_set_wait(const struct lu_env *env, struct ptlrpc_request_set *);
2096 void ptlrpc_set_destroy(struct ptlrpc_request_set *);
2097 void ptlrpc_set_add_req(struct ptlrpc_request_set *, struct ptlrpc_request *);
2098 #define PTLRPCD_SET ((struct ptlrpc_request_set *)1)
2099
2100 void ptlrpc_free_rq_pool(struct ptlrpc_request_pool *pool);
2101 int ptlrpc_add_rqs_to_pool(struct ptlrpc_request_pool *pool, int num_rq);
2102
2103 struct ptlrpc_request_pool *
2104 ptlrpc_init_rq_pool(int, int,
2105                     int (*populate_pool)(struct ptlrpc_request_pool *, int));
2106
2107 void ptlrpc_at_set_req_timeout(struct ptlrpc_request *req);
2108 struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp,
2109                                             const struct req_format *format);
2110 struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp,
2111                                             struct ptlrpc_request_pool *,
2112                                             const struct req_format *format);
2113 void ptlrpc_request_free(struct ptlrpc_request *request);
2114 int ptlrpc_request_pack(struct ptlrpc_request *request,
2115                         __u32 version, int opcode);
2116 struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp,
2117                                                 const struct req_format *format,
2118                                                 __u32 version, int opcode);
2119 int ptlrpc_request_bufs_pack(struct ptlrpc_request *request,
2120                              __u32 version, int opcode, char **bufs,
2121                              struct ptlrpc_cli_ctx *ctx);
2122 void ptlrpc_req_finished(struct ptlrpc_request *request);
2123 void ptlrpc_req_finished_with_imp_lock(struct ptlrpc_request *request);
2124 struct ptlrpc_request *ptlrpc_request_addref(struct ptlrpc_request *req);
2125 struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_imp(struct ptlrpc_request *req,
2126                                               unsigned nfrags, unsigned max_brw,
2127                                               unsigned int type,
2128                                               unsigned portal,
2129                                               const struct ptlrpc_bulk_frag_ops
2130                                                 *ops);
2131
2132 void __ptlrpc_prep_bulk_page(struct ptlrpc_bulk_desc *desc,
2133                              struct page *page, int pageoffset, int len,
2134                              int pin);
2135
2136 void ptlrpc_free_bulk(struct ptlrpc_bulk_desc *bulk);
2137
2138 static inline void ptlrpc_release_bulk_noop(struct ptlrpc_bulk_desc *desc)
2139 {
2140 }
2141
2142 void ptlrpc_retain_replayable_request(struct ptlrpc_request *req,
2143                                       struct obd_import *imp);
2144 __u64 ptlrpc_next_xid(void);
2145 __u64 ptlrpc_sample_next_xid(void);
2146 __u64 ptlrpc_req_xid(struct ptlrpc_request *request);
2147 void ptlrpc_get_mod_rpc_slot(struct ptlrpc_request *req);
2148 void ptlrpc_put_mod_rpc_slot(struct ptlrpc_request *req);
2149
2150 /* Set of routines to run a function in ptlrpcd context */
2151 void *ptlrpcd_alloc_work(struct obd_import *imp,
2152                          int (*cb)(const struct lu_env *, void *), void *data);
2153 void ptlrpcd_destroy_work(void *handler);
2154 int ptlrpcd_queue_work(void *handler);
2155
2156 /** @} */
2157 struct ptlrpc_service_buf_conf {
2158         /* nbufs is buffers # to allocate when growing the pool */
2159         unsigned int                    bc_nbufs;
2160         /* buffer size to post */
2161         unsigned int                    bc_buf_size;
2162         /* portal to listed for requests on */
2163         unsigned int                    bc_req_portal;
2164         /* portal of where to send replies to */
2165         unsigned int                    bc_rep_portal;
2166         /* maximum request size to be accepted for this service */
2167         unsigned int                    bc_req_max_size;
2168         /* maximum reply size this service can ever send */
2169         unsigned int                    bc_rep_max_size;
2170 };
2171
2172 struct ptlrpc_service_thr_conf {
2173         /* threadname should be 8 characters or less - 6 will be added on */
2174         char                            *tc_thr_name;
2175         /* threads increasing factor for each CPU */
2176         unsigned int                    tc_thr_factor;
2177         /* service threads # to start on each partition while initializing */
2178         unsigned int                    tc_nthrs_init;
2179         /*
2180          * low water of threads # upper-limit on each partition while running,
2181          * service availability may be impacted if threads number is lower
2182          * than this value. It can be ZERO if the service doesn't require
2183          * CPU affinity or there is only one partition.
2184          */
2185         unsigned int                    tc_nthrs_base;
2186         /* "soft" limit for total threads number */
2187         unsigned int                    tc_nthrs_max;
2188         /* user specified threads number, it will be validated due to
2189          * other members of this structure. */
2190         unsigned int                    tc_nthrs_user;
2191         /* bind service threads to only CPUs in their associated CPT */
2192         unsigned int                    tc_cpu_bind;
2193         /* Tags for lu_context associated with service thread */
2194         __u32                           tc_ctx_tags;
2195 };
2196
2197 struct ptlrpc_service_cpt_conf {
2198         struct cfs_cpt_table            *cc_cptable;
2199         /* string pattern to describe CPTs for a service */
2200         char                            *cc_pattern;
2201         /* whether or not to have per-CPT service partitions */
2202         bool                            cc_affinity;
2203 };
2204
2205 struct ptlrpc_service_conf {
2206         /* service name */
2207         char                            *psc_name;
2208         /* soft watchdog timeout multiplifier to print stuck service traces */
2209         unsigned int                    psc_watchdog_factor;
2210         /* buffer information */
2211         struct ptlrpc_service_buf_conf  psc_buf;
2212         /* thread information */
2213         struct ptlrpc_service_thr_conf  psc_thr;
2214         /* CPU partition information */
2215         struct ptlrpc_service_cpt_conf  psc_cpt;
2216         /* function table */
2217         struct ptlrpc_service_ops       psc_ops;
2218 };
2219
2220 /* ptlrpc/service.c */
2221 /**
2222  * Server-side services API. Register/unregister service, request state
2223  * management, service thread management
2224  *
2225  * @{
2226  */
2227 void ptlrpc_save_lock(struct ptlrpc_request *req, struct lustre_handle *lock,
2228                       int mode, bool no_ack, bool convert_lock);
2229 void ptlrpc_commit_replies(struct obd_export *exp);
2230 void ptlrpc_dispatch_difficult_reply(struct ptlrpc_reply_state *rs);
2231 void ptlrpc_schedule_difficult_reply(struct ptlrpc_reply_state *rs);
2232 int ptlrpc_hpreq_handler(struct ptlrpc_request *req);
2233 struct ptlrpc_service *ptlrpc_register_service(
2234                                 struct ptlrpc_service_conf *conf,
2235                                 struct kset *parent,
2236                                 struct dentry *debugfs_entry);
2237 void ptlrpc_stop_all_threads(struct ptlrpc_service *svc);
2238
2239 int ptlrpc_start_threads(struct ptlrpc_service *svc);
2240 int ptlrpc_unregister_service(struct ptlrpc_service *service);
2241 int ptlrpc_service_health_check(struct ptlrpc_service *);
2242 void ptlrpc_server_drop_request(struct ptlrpc_request *req);
2243 void ptlrpc_request_change_export(struct ptlrpc_request *req,
2244                                   struct obd_export *export);
2245 void ptlrpc_update_export_timer(struct obd_export *exp,
2246                                 time64_t extra_delay);
2247
2248 int ptlrpc_hr_init(void);
2249 void ptlrpc_hr_fini(void);
2250
2251 /** @} */
2252
2253 /* ptlrpc/import.c */
2254 /**
2255  * Import API
2256  * @{
2257  */
2258 int ptlrpc_connect_import(struct obd_import *imp);
2259 int ptlrpc_connect_import_locked(struct obd_import *imp);
2260 int ptlrpc_init_import(struct obd_import *imp);
2261 int ptlrpc_disconnect_import(struct obd_import *imp, int noclose);
2262 int ptlrpc_disconnect_and_idle_import(struct obd_import *imp);
2263 int ptlrpc_import_recovery_state_machine(struct obd_import *imp);
2264 void deuuidify(char *uuid, const char *prefix, char **uuid_start,
2265                int *uuid_len);
2266 void ptlrpc_import_enter_resend(struct obd_import *imp);
2267 /* ptlrpc/pack_generic.c */
2268 int ptlrpc_reconnect_import(struct obd_import *imp);
2269 /** @} */
2270
2271 /**
2272  * ptlrpc msg buffer and swab interface
2273  *
2274  * @{
2275  */
2276 #define PTLRPC_MAX_BUFCOUNT \
2277         (sizeof(((struct ptlrpc_request *)0)->rq_req_swab_mask) * 8)
2278 #define MD_MAX_BUFLEN           (MDS_REG_MAXREQSIZE > OUT_MAXREQSIZE ? \
2279                                  MDS_REG_MAXREQSIZE : OUT_MAXREQSIZE)
2280 #define PTLRPC_MAX_BUFLEN       (OST_IO_MAXREQSIZE > MD_MAX_BUFLEN ? \
2281                                  OST_IO_MAXREQSIZE : MD_MAX_BUFLEN)
2282 bool ptlrpc_buf_need_swab(struct ptlrpc_request *req, const int inout,
2283                           __u32 index);
2284 void ptlrpc_buf_set_swabbed(struct ptlrpc_request *req, const int inout,
2285                             __u32 index);
2286 int ptlrpc_unpack_rep_msg(struct ptlrpc_request *req, int len);
2287 int ptlrpc_unpack_req_msg(struct ptlrpc_request *req, int len);
2288
2289 int lustre_msg_check_version(struct lustre_msg *msg, __u32 version);
2290 void lustre_init_msg_v2(struct lustre_msg_v2 *msg, int count, __u32 *lens,
2291                         char **bufs);
2292 int lustre_pack_request(struct ptlrpc_request *, __u32 magic, int count,
2293                         __u32 *lens, char **bufs);
2294 int lustre_pack_reply(struct ptlrpc_request *, int count, __u32 *lens,
2295                       char **bufs);
2296 int lustre_pack_reply_v2(struct ptlrpc_request *req, int count,
2297                          __u32 *lens, char **bufs, int flags);
2298 #define LPRFL_EARLY_REPLY 1
2299 int lustre_pack_reply_flags(struct ptlrpc_request *, int count, __u32 *lens,
2300                             char **bufs, int flags);
2301 int lustre_shrink_msg(struct lustre_msg *msg, int segment,
2302                       unsigned int newlen, int move_data);
2303 int lustre_grow_msg(struct lustre_msg *msg, int segment, unsigned int newlen);
2304 void lustre_free_reply_state(struct ptlrpc_reply_state *rs);
2305 int __lustre_unpack_msg(struct lustre_msg *m, int len);
2306 __u32 lustre_msg_hdr_size(__u32 magic, __u32 count);
2307 __u32 lustre_msg_size(__u32 magic, int count, __u32 *lengths);
2308 __u32 lustre_msg_size_v2(int count, __u32 *lengths);
2309 __u32 lustre_packed_msg_size(struct lustre_msg *msg);
2310 __u32 lustre_msg_early_size(void);
2311 void *lustre_msg_buf_v2(struct lustre_msg_v2 *m, __u32 n, __u32 min_size);
2312 void *lustre_msg_buf(struct lustre_msg *m, __u32 n, __u32 minlen);
2313 __u32 lustre_msg_buflen(struct lustre_msg *m, __u32 n);
2314 void lustre_msg_set_buflen(struct lustre_msg *m, __u32 n, __u32 len);
2315 __u32 lustre_msg_bufcount(struct lustre_msg *m);
2316 char *lustre_msg_string(struct lustre_msg *m, __u32 n, __u32 max_len);
2317 __u32 lustre_msghdr_get_flags(struct lustre_msg *msg);
2318 void lustre_msghdr_set_flags(struct lustre_msg *msg, __u32 flags);
2319 __u32 lustre_msg_get_flags(struct lustre_msg *msg);
2320 void lustre_msg_add_flags(struct lustre_msg *msg, __u32 flags);
2321 void lustre_msg_set_flags(struct lustre_msg *msg, __u32 flags);
2322 void lustre_msg_clear_flags(struct lustre_msg *msg, __u32 flags);
2323 __u32 lustre_msg_get_op_flags(struct lustre_msg *msg);
2324 void lustre_msg_add_op_flags(struct lustre_msg *msg, __u32 flags);
2325 struct lustre_handle *lustre_msg_get_handle(struct lustre_msg *msg);
2326 __u32 lustre_msg_get_type(struct lustre_msg *msg);
2327 enum lustre_msg_version lustre_msg_get_version(struct lustre_msg *msg);
2328 void lustre_msg_add_version(struct lustre_msg *msg, __u32 version);
2329 __u32 lustre_msg_get_opc(struct lustre_msg *msg);
2330 __u64 lustre_msg_get_last_xid(struct lustre_msg *msg);
2331 __u16 lustre_msg_get_tag(struct lustre_msg *msg);
2332 __u64 lustre_msg_get_last_committed(struct lustre_msg *msg);
2333 __u64 *lustre_msg_get_versions(struct lustre_msg *msg);
2334 __u64 lustre_msg_get_transno(struct lustre_msg *msg);
2335 __u64 lustre_msg_get_slv(struct lustre_msg *msg);
2336 __u32 lustre_msg_get_limit(struct lustre_msg *msg);
2337 void lustre_msg_set_slv(struct lustre_msg *msg, __u64 slv);
2338 void lustre_msg_set_limit(struct lustre_msg *msg, __u64 limit);
2339 int lustre_msg_get_status(struct lustre_msg *msg);
2340 __u32 lustre_msg_get_conn_cnt(struct lustre_msg *msg);
2341 __u32 lustre_msg_get_magic(struct lustre_msg *msg);
2342 timeout_t lustre_msg_get_timeout(struct lustre_msg *msg);
2343 timeout_t lustre_msg_get_service_timeout(struct lustre_msg *msg);
2344 char *lustre_msg_get_jobid(struct lustre_msg *msg);
2345 __u32 lustre_msg_get_cksum(struct lustre_msg *msg);
2346 __u64 lustre_msg_get_mbits(struct lustre_msg *msg);
2347 __u32 lustre_msg_calc_cksum(struct lustre_msg *msg);
2348 void lustre_msg_set_handle(struct lustre_msg *msg,struct lustre_handle *handle);
2349 void lustre_msg_set_type(struct lustre_msg *msg, __u32 type);
2350 void lustre_msg_set_opc(struct lustre_msg *msg, __u32 opc);
2351 void lustre_msg_set_last_xid(struct lustre_msg *msg, __u64 last_xid);
2352 void lustre_msg_set_tag(struct lustre_msg *msg, __u16 tag);
2353 void lustre_msg_set_last_committed(struct lustre_msg *msg,__u64 last_committed);
2354 void lustre_msg_set_versions(struct lustre_msg *msg, __u64 *versions);
2355 void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno);
2356 void lustre_msg_set_status(struct lustre_msg *msg, __u32 status);
2357 void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt);
2358 void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, __u32 *sizes);
2359 void ptlrpc_request_set_replen(struct ptlrpc_request *req);
2360 void lustre_msg_set_timeout(struct lustre_msg *msg, timeout_t timeout);
2361 void lustre_msg_set_service_timeout(struct lustre_msg *msg,
2362                                     timeout_t service_timeout);
2363 void lustre_msg_set_jobid(struct lustre_msg *msg, char *jobid);
2364 void lustre_msg_set_cksum(struct lustre_msg *msg, __u32 cksum);
2365 void lustre_msg_set_mbits(struct lustre_msg *msg, __u64 mbits);
2366
2367 static inline void
2368 lustre_shrink_reply(struct ptlrpc_request *req, int segment,
2369                     unsigned int newlen, int move_data)
2370 {
2371         LASSERT(req->rq_reply_state);
2372         LASSERT(req->rq_repmsg);
2373         req->rq_replen = lustre_shrink_msg(req->rq_repmsg, segment,
2374                                            newlen, move_data);
2375 }
2376
2377 #ifdef LUSTRE_TRANSLATE_ERRNOS
2378
2379 static inline int ptlrpc_status_hton(int h)
2380 {
2381         /*
2382          * Positive errnos must be network errnos, such as LUSTRE_EDEADLK,
2383          * ELDLM_LOCK_ABORTED, etc.
2384          */
2385         if (h < 0)
2386                 return -lustre_errno_hton(-h);
2387         else
2388                 return h;
2389 }
2390
2391 static inline int ptlrpc_status_ntoh(int n)
2392 {
2393         /*
2394          * See the comment in ptlrpc_status_hton().
2395          */
2396         if (n < 0)
2397                 return -lustre_errno_ntoh(-n);
2398         else
2399                 return n;
2400 }
2401
2402 #else
2403
2404 #define ptlrpc_status_hton(h) (h)
2405 #define ptlrpc_status_ntoh(n) (n)
2406
2407 #endif
2408 /** @} */
2409
2410 /** Change request phase of \a req to \a new_phase */
2411 static inline void
2412 ptlrpc_rqphase_move(struct ptlrpc_request *req, enum rq_phase new_phase)
2413 {
2414         if (req->rq_phase == new_phase)
2415                 return;
2416
2417         if (new_phase == RQ_PHASE_UNREG_RPC ||
2418             new_phase == RQ_PHASE_UNREG_BULK) {
2419                 /* No embedded unregistering phases */
2420                 if (req->rq_phase == RQ_PHASE_UNREG_RPC ||
2421                     req->rq_phase == RQ_PHASE_UNREG_BULK)
2422                         return;
2423
2424                 req->rq_next_phase = req->rq_phase;
2425                 if (req->rq_import)
2426                         atomic_inc(&req->rq_import->imp_unregistering);
2427         }
2428
2429         if (req->rq_phase == RQ_PHASE_UNREG_RPC ||
2430             req->rq_phase == RQ_PHASE_UNREG_BULK) {
2431                 if (req->rq_import)
2432                         atomic_dec(&req->rq_import->imp_unregistering);
2433         }
2434
2435         DEBUG_REQ(D_INFO, req, "move request phase from %s to %s",
2436                   ptlrpc_rqphase2str(req), ptlrpc_phase2str(new_phase));
2437
2438         req->rq_phase = new_phase;
2439 }
2440
2441 /**
2442  * Returns true if request \a req got early reply and hard deadline is not met
2443  */
2444 static inline int
2445 ptlrpc_client_early(struct ptlrpc_request *req)
2446 {
2447         return req->rq_early;
2448 }
2449
2450 /**
2451  * Returns true if we got real reply from server for this request
2452  */
2453 static inline int
2454 ptlrpc_client_replied(struct ptlrpc_request *req)
2455 {
2456         if (req->rq_reply_deadline > ktime_get_real_seconds())
2457                 return 0;
2458         return req->rq_replied;
2459 }
2460
2461 /** Returns true if request \a req is in process of receiving server reply */
2462 static inline int
2463 ptlrpc_client_recv(struct ptlrpc_request *req)
2464 {
2465         if (req->rq_reply_deadline > ktime_get_real_seconds())
2466                 return 1;
2467         return req->rq_receiving_reply;
2468 }
2469
2470 static inline int
2471 ptlrpc_client_recv_or_unlink(struct ptlrpc_request *req)
2472 {
2473         int rc;
2474
2475         spin_lock(&req->rq_lock);
2476         if (req->rq_reply_deadline > ktime_get_real_seconds()) {
2477                 spin_unlock(&req->rq_lock);
2478                 return 1;
2479         }
2480         if (req->rq_req_deadline > ktime_get_real_seconds()) {
2481                 spin_unlock(&req->rq_lock);
2482                 return 1;
2483         }
2484
2485         rc = !req->rq_req_unlinked || !req->rq_reply_unlinked ||
2486              req->rq_receiving_reply;
2487         spin_unlock(&req->rq_lock);
2488         return rc;
2489 }
2490
2491 static inline void
2492 ptlrpc_client_wake_req(struct ptlrpc_request *req)
2493 {
2494         smp_mb();
2495         if (req->rq_set == NULL)
2496                 wake_up(&req->rq_reply_waitq);
2497         else
2498                 wake_up(&req->rq_set->set_waitq);
2499 }
2500
2501 static inline void
2502 ptlrpc_rs_addref(struct ptlrpc_reply_state *rs)
2503 {
2504         LASSERT(atomic_read(&rs->rs_refcount) > 0);
2505         atomic_inc(&rs->rs_refcount);
2506 }
2507
2508 static inline void
2509 ptlrpc_rs_decref(struct ptlrpc_reply_state *rs)
2510 {
2511         LASSERT(atomic_read(&rs->rs_refcount) > 0);
2512         if (atomic_dec_and_test(&rs->rs_refcount))
2513                 lustre_free_reply_state(rs);
2514 }
2515
2516 /* Should only be called once per req */
2517 static inline void ptlrpc_req_drop_rs(struct ptlrpc_request *req)
2518 {
2519         if (req->rq_reply_state == NULL)
2520                 return; /* shouldn't occur */
2521         ptlrpc_rs_decref(req->rq_reply_state);
2522         req->rq_reply_state = NULL;
2523         req->rq_repmsg = NULL;
2524 }
2525
2526 static inline __u32 lustre_request_magic(struct ptlrpc_request *req)
2527 {
2528         return lustre_msg_get_magic(req->rq_reqmsg);
2529 }
2530
2531 static inline int ptlrpc_req_get_repsize(struct ptlrpc_request *req)
2532 {
2533         switch (req->rq_reqmsg->lm_magic) {
2534         case LUSTRE_MSG_MAGIC_V2:
2535                 return req->rq_reqmsg->lm_repsize;
2536         default:
2537                 LASSERTF(0, "incorrect message magic: %08x\n",
2538                          req->rq_reqmsg->lm_magic);
2539                 return -EFAULT;
2540         }
2541 }
2542
2543 static inline int ptlrpc_send_limit_expired(struct ptlrpc_request *req)
2544 {
2545         if (req->rq_delay_limit != 0 &&
2546             req->rq_queued_time + req->rq_delay_limit < ktime_get_seconds())
2547                 return 1;
2548         return 0;
2549 }
2550
2551 static inline int ptlrpc_no_resend(struct ptlrpc_request *req)
2552 {
2553         if (!req->rq_no_resend && ptlrpc_send_limit_expired(req)) {
2554                 spin_lock(&req->rq_lock);
2555                 req->rq_no_resend = 1;
2556                 spin_unlock(&req->rq_lock);
2557         }
2558         return req->rq_no_resend;
2559 }
2560
2561 static inline int
2562 ptlrpc_server_get_timeout(struct ptlrpc_service_part *svcpt)
2563 {
2564         int at = AT_OFF ? 0 : at_get(&svcpt->scp_at_estimate);
2565
2566         return svcpt->scp_service->srv_watchdog_factor *
2567                max_t(int, at, obd_timeout);
2568 }
2569
2570 /**
2571  * Calculate the amount of time for lock prolongation.
2572  *
2573  * This is helper function to get the timeout extra time.
2574  *
2575  * @req         current request
2576  *
2577  * Return:      amount of time to extend the timeout with
2578  */
2579 static inline timeout_t prolong_timeout(struct ptlrpc_request *req)
2580 {
2581         struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
2582         timeout_t req_timeout = 0;
2583
2584         if (AT_OFF)
2585                 return obd_timeout / 2;
2586
2587         if (req->rq_deadline > req->rq_arrival_time.tv_sec)
2588                 req_timeout = req->rq_deadline - req->rq_arrival_time.tv_sec;
2589
2590         return max(req_timeout,
2591                    at_est2timeout(at_get(&svcpt->scp_at_estimate)));
2592 }
2593
2594 static inline struct ptlrpc_service *
2595 ptlrpc_req2svc(struct ptlrpc_request *req)
2596 {
2597         LASSERT(req->rq_rqbd != NULL);
2598         return req->rq_rqbd->rqbd_svcpt->scp_service;
2599 }
2600
2601 /* ldlm/ldlm_lib.c */
2602 /**
2603  * Target client logic
2604  * @{
2605  */
2606 int client_obd_setup(struct obd_device *obd, struct lustre_cfg *lcfg);
2607 int client_obd_cleanup(struct obd_device *obd);
2608 int client_connect_import(const struct lu_env *env,
2609                           struct obd_export **exp, struct obd_device *obd,
2610                           struct obd_uuid *cluuid, struct obd_connect_data *,
2611                           void *localdata);
2612 int client_disconnect_export(struct obd_export *exp);
2613 int client_import_add_conn(struct obd_import *imp, struct obd_uuid *uuid,
2614                            int priority);
2615 int client_import_del_conn(struct obd_import *imp, struct obd_uuid *uuid);
2616 int client_import_find_conn(struct obd_import *imp, lnet_nid_t peer,
2617                             struct obd_uuid *uuid);
2618 int import_set_conn_priority(struct obd_import *imp, struct obd_uuid *uuid);
2619 void client_destroy_import(struct obd_import *imp);
2620 /** @} */
2621
2622 #ifdef HAVE_SERVER_SUPPORT
2623 int server_disconnect_export(struct obd_export *exp);
2624 #endif
2625
2626 /* ptlrpc/pinger.c */
2627 /**
2628  * Pinger API (client side only)
2629  * @{
2630  */
2631 enum timeout_event {
2632         TIMEOUT_GRANT = 1
2633 };
2634 struct timeout_item;
2635 typedef int (*timeout_cb_t)(struct timeout_item *, void *);
2636 int ptlrpc_pinger_add_import(struct obd_import *imp);
2637 int ptlrpc_pinger_del_import(struct obd_import *imp);
2638 int ptlrpc_add_timeout_client(time64_t time, enum timeout_event event,
2639                               timeout_cb_t cb, void *data,
2640                               struct list_head *obd_list);
2641 int ptlrpc_del_timeout_client(struct list_head *obd_list,
2642                               enum timeout_event event);
2643 struct ptlrpc_request * ptlrpc_prep_ping(struct obd_import *imp);
2644 int ptlrpc_obd_ping(struct obd_device *obd);
2645 void ping_evictor_start(void);
2646 void ping_evictor_stop(void);
2647 void ptlrpc_pinger_ir_up(void);
2648 void ptlrpc_pinger_ir_down(void);
2649 /** @} */
2650 int ptlrpc_pinger_suppress_pings(void);
2651
2652 /* ptlrpc/ptlrpcd.c */
2653 void ptlrpcd_stop(struct ptlrpcd_ctl *pc, int force);
2654 void ptlrpcd_free(struct ptlrpcd_ctl *pc);
2655 void ptlrpcd_wake(struct ptlrpc_request *req);
2656 void ptlrpcd_add_req(struct ptlrpc_request *req);
2657 void ptlrpcd_add_rqset(struct ptlrpc_request_set *set);
2658 int ptlrpcd_addref(void);
2659 void ptlrpcd_decref(void);
2660
2661 /* ptlrpc/lproc_ptlrpc.c */
2662 /**
2663  * procfs output related functions
2664  * @{
2665  */
2666 const char* ll_opcode2str(__u32 opcode);
2667 const int ll_str2opcode(const char *ops);
2668 #ifdef CONFIG_PROC_FS
2669 void ptlrpc_lprocfs_register_obd(struct obd_device *obd);
2670 void ptlrpc_lprocfs_unregister_obd(struct obd_device *obd);
2671 void ptlrpc_lprocfs_brw(struct ptlrpc_request *req, int bytes);
2672 #else
2673 static inline void ptlrpc_lprocfs_register_obd(struct obd_device *obd) {}
2674 static inline void ptlrpc_lprocfs_unregister_obd(struct obd_device *obd) {}
2675 static inline void ptlrpc_lprocfs_brw(struct ptlrpc_request *req, int bytes) {}
2676 #endif
2677 /** @} */
2678
2679 /* ptlrpc/llog_server.c */
2680 int llog_origin_handle_open(struct ptlrpc_request *req);
2681 int llog_origin_handle_prev_block(struct ptlrpc_request *req);
2682 int llog_origin_handle_next_block(struct ptlrpc_request *req);
2683 int llog_origin_handle_read_header(struct ptlrpc_request *req);
2684
2685 /* ptlrpc/llog_client.c */
2686 extern struct llog_operations llog_client_ops;
2687 /** @} net */
2688
2689 #endif
2690 /** @} PtlRPC */