4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
27 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
37 #define DEBUG_SUBSYSTEM S_MDC
38 #include "../include/lustre_net.h"
39 #include "../include/lustre/lustre_idl.h"
40 #include "mdc_internal.h"
43 static void __mdc_pack_body(struct mdt_body
*b
, __u32 suppgid
)
48 b
->uid
= from_kuid(&init_user_ns
, current_uid());
49 b
->gid
= from_kgid(&init_user_ns
, current_gid());
50 b
->fsuid
= from_kuid(&init_user_ns
, current_fsuid());
51 b
->fsgid
= from_kgid(&init_user_ns
, current_fsgid());
52 b
->capability
= cfs_curproc_cap_pack();
55 void mdc_pack_capa(struct ptlrpc_request
*req
,
56 const struct req_msg_field
*field
,
59 struct req_capsule
*pill
= &req
->rq_pill
;
60 struct lustre_capa
*c
;
63 LASSERT(req_capsule_get_size(pill
, field
, RCL_CLIENT
) == 0);
67 c
= req_capsule_client_get(pill
, field
);
70 DEBUG_CAPA(D_SEC
, c
, "pack");
73 void mdc_is_subdir_pack(struct ptlrpc_request
*req
, const struct lu_fid
*pfid
,
74 const struct lu_fid
*cfid
, int flags
)
76 struct mdt_body
*b
= req_capsule_client_get(&req
->rq_pill
,
81 b
->valid
= OBD_MD_FLID
;
88 void mdc_swap_layouts_pack(struct ptlrpc_request
*req
,
89 struct md_op_data
*op_data
)
91 struct mdt_body
*b
= req_capsule_client_get(&req
->rq_pill
,
94 __mdc_pack_body(b
, op_data
->op_suppgids
[0]);
95 b
->fid1
= op_data
->op_fid1
;
96 b
->fid2
= op_data
->op_fid2
;
97 b
->valid
|= OBD_MD_FLID
;
99 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
100 mdc_pack_capa(req
, &RMF_CAPA2
, op_data
->op_capa2
);
103 void mdc_pack_body(struct ptlrpc_request
*req
,
104 const struct lu_fid
*fid
, struct obd_capa
*oc
,
105 __u64 valid
, int ea_size
, __u32 suppgid
, int flags
)
107 struct mdt_body
*b
= req_capsule_client_get(&req
->rq_pill
,
111 b
->eadatasize
= ea_size
;
113 __mdc_pack_body(b
, suppgid
);
116 b
->valid
|= OBD_MD_FLID
;
117 mdc_pack_capa(req
, &RMF_CAPA1
, oc
);
121 void mdc_readdir_pack(struct ptlrpc_request
*req
, __u64 pgoff
,
122 __u32 size
, const struct lu_fid
*fid
, struct obd_capa
*oc
)
124 struct mdt_body
*b
= req_capsule_client_get(&req
->rq_pill
,
127 b
->valid
|= OBD_MD_FLID
;
128 b
->size
= pgoff
; /* !! */
129 b
->nlink
= size
; /* !! */
130 __mdc_pack_body(b
, -1);
131 b
->mode
= LUDA_FID
| LUDA_TYPE
;
133 mdc_pack_capa(req
, &RMF_CAPA1
, oc
);
136 /* packing of MDS records */
137 void mdc_create_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
,
138 const void *data
, int datalen
, __u32 mode
,
139 __u32 uid
, __u32 gid
, cfs_cap_t cap_effective
, __u64 rdev
)
141 struct mdt_rec_create
*rec
;
145 CLASSERT(sizeof(struct mdt_rec_reint
) == sizeof(struct mdt_rec_create
));
146 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
149 rec
->cr_opcode
= REINT_CREATE
;
152 rec
->cr_cap
= cap_effective
;
153 rec
->cr_fid1
= op_data
->op_fid1
;
154 rec
->cr_fid2
= op_data
->op_fid2
;
157 rec
->cr_time
= op_data
->op_mod_time
;
158 rec
->cr_suppgid1
= op_data
->op_suppgids
[0];
159 rec
->cr_suppgid2
= op_data
->op_suppgids
[1];
160 flags
= op_data
->op_flags
& MF_SOM_LOCAL_FLAGS
;
161 if (op_data
->op_bias
& MDS_CREATE_VOLATILE
)
162 flags
|= MDS_OPEN_VOLATILE
;
163 set_mrc_cr_flags(rec
, flags
);
164 rec
->cr_bias
= op_data
->op_bias
;
165 rec
->cr_umask
= current_umask();
167 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
169 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_NAME
);
170 LOGL0(op_data
->op_name
, op_data
->op_namelen
, tmp
);
173 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_EADATA
);
174 memcpy(tmp
, data
, datalen
);
178 static __u64
mds_pack_open_flags(__u64 flags
, __u32 mode
)
180 __u64 cr_flags
= (flags
& (FMODE_READ
| FMODE_WRITE
|
181 MDS_OPEN_HAS_EA
| MDS_OPEN_HAS_OBJS
|
182 MDS_OPEN_OWNEROVERRIDE
| MDS_OPEN_LOCK
|
183 MDS_OPEN_BY_FID
| MDS_OPEN_LEASE
|
186 cr_flags
|= MDS_OPEN_CREAT
;
188 cr_flags
|= MDS_OPEN_EXCL
;
190 cr_flags
|= MDS_OPEN_TRUNC
;
191 if (flags
& O_APPEND
)
192 cr_flags
|= MDS_OPEN_APPEND
;
194 cr_flags
|= MDS_OPEN_SYNC
;
195 if (flags
& O_DIRECTORY
)
196 cr_flags
|= MDS_OPEN_DIRECTORY
;
197 if (flags
& __FMODE_EXEC
)
198 cr_flags
|= MDS_FMODE_EXEC
;
199 if (cl_is_lov_delay_create(flags
))
200 cr_flags
|= MDS_OPEN_DELAY_CREATE
;
202 if (flags
& O_NONBLOCK
)
203 cr_flags
|= MDS_OPEN_NORESTORE
;
208 /* packing of MDS records */
209 void mdc_open_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
,
210 __u32 mode
, __u64 rdev
, __u64 flags
, const void *lmm
,
213 struct mdt_rec_create
*rec
;
217 CLASSERT(sizeof(struct mdt_rec_reint
) == sizeof(struct mdt_rec_create
));
218 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
220 /* XXX do something about time, uid, gid */
221 rec
->cr_opcode
= REINT_OPEN
;
222 rec
->cr_fsuid
= from_kuid(&init_user_ns
, current_fsuid());
223 rec
->cr_fsgid
= from_kgid(&init_user_ns
, current_fsgid());
224 rec
->cr_cap
= cfs_curproc_cap_pack();
225 if (op_data
!= NULL
) {
226 rec
->cr_fid1
= op_data
->op_fid1
;
227 rec
->cr_fid2
= op_data
->op_fid2
;
230 cr_flags
= mds_pack_open_flags(flags
, mode
);
232 rec
->cr_time
= op_data
->op_mod_time
;
233 rec
->cr_suppgid1
= op_data
->op_suppgids
[0];
234 rec
->cr_suppgid2
= op_data
->op_suppgids
[1];
235 rec
->cr_bias
= op_data
->op_bias
;
236 rec
->cr_umask
= current_umask();
237 rec
->cr_old_handle
= op_data
->op_handle
;
239 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
240 /* the next buffer is child capa, which is used for replay,
241 * will be packed from the data in reply message. */
243 if (op_data
->op_name
) {
244 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_NAME
);
245 LOGL0(op_data
->op_name
, op_data
->op_namelen
, tmp
);
246 if (op_data
->op_bias
& MDS_CREATE_VOLATILE
)
247 cr_flags
|= MDS_OPEN_VOLATILE
;
251 cr_flags
|= MDS_OPEN_HAS_EA
;
252 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_EADATA
);
253 memcpy(tmp
, lmm
, lmmlen
);
255 set_mrc_cr_flags(rec
, cr_flags
);
258 static inline __u64
attr_pack(unsigned int ia_valid
)
262 if (ia_valid
& ATTR_MODE
)
263 sa_valid
|= MDS_ATTR_MODE
;
264 if (ia_valid
& ATTR_UID
)
265 sa_valid
|= MDS_ATTR_UID
;
266 if (ia_valid
& ATTR_GID
)
267 sa_valid
|= MDS_ATTR_GID
;
268 if (ia_valid
& ATTR_SIZE
)
269 sa_valid
|= MDS_ATTR_SIZE
;
270 if (ia_valid
& ATTR_ATIME
)
271 sa_valid
|= MDS_ATTR_ATIME
;
272 if (ia_valid
& ATTR_MTIME
)
273 sa_valid
|= MDS_ATTR_MTIME
;
274 if (ia_valid
& ATTR_CTIME
)
275 sa_valid
|= MDS_ATTR_CTIME
;
276 if (ia_valid
& ATTR_ATIME_SET
)
277 sa_valid
|= MDS_ATTR_ATIME_SET
;
278 if (ia_valid
& ATTR_MTIME_SET
)
279 sa_valid
|= MDS_ATTR_MTIME_SET
;
280 if (ia_valid
& ATTR_FORCE
)
281 sa_valid
|= MDS_ATTR_FORCE
;
282 if (ia_valid
& ATTR_ATTR_FLAG
)
283 sa_valid
|= MDS_ATTR_ATTR_FLAG
;
284 if (ia_valid
& ATTR_KILL_SUID
)
285 sa_valid
|= MDS_ATTR_KILL_SUID
;
286 if (ia_valid
& ATTR_KILL_SGID
)
287 sa_valid
|= MDS_ATTR_KILL_SGID
;
288 if (ia_valid
& ATTR_CTIME_SET
)
289 sa_valid
|= MDS_ATTR_CTIME_SET
;
290 if (ia_valid
& ATTR_FROM_OPEN
)
291 sa_valid
|= MDS_ATTR_FROM_OPEN
;
292 if (ia_valid
& ATTR_BLOCKS
)
293 sa_valid
|= MDS_ATTR_BLOCKS
;
294 if (ia_valid
& MDS_OPEN_OWNEROVERRIDE
)
295 /* NFSD hack (see bug 5781) */
296 sa_valid
|= MDS_OPEN_OWNEROVERRIDE
;
300 static void mdc_setattr_pack_rec(struct mdt_rec_setattr
*rec
,
301 struct md_op_data
*op_data
)
303 rec
->sa_opcode
= REINT_SETATTR
;
304 rec
->sa_fsuid
= from_kuid(&init_user_ns
, current_fsuid());
305 rec
->sa_fsgid
= from_kgid(&init_user_ns
, current_fsgid());
306 rec
->sa_cap
= cfs_curproc_cap_pack();
307 rec
->sa_suppgid
= -1;
309 rec
->sa_fid
= op_data
->op_fid1
;
310 rec
->sa_valid
= attr_pack(op_data
->op_attr
.ia_valid
);
311 rec
->sa_mode
= op_data
->op_attr
.ia_mode
;
312 rec
->sa_uid
= from_kuid(&init_user_ns
, op_data
->op_attr
.ia_uid
);
313 rec
->sa_gid
= from_kgid(&init_user_ns
, op_data
->op_attr
.ia_gid
);
314 rec
->sa_size
= op_data
->op_attr
.ia_size
;
315 rec
->sa_blocks
= op_data
->op_attr_blocks
;
316 rec
->sa_atime
= LTIME_S(op_data
->op_attr
.ia_atime
);
317 rec
->sa_mtime
= LTIME_S(op_data
->op_attr
.ia_mtime
);
318 rec
->sa_ctime
= LTIME_S(op_data
->op_attr
.ia_ctime
);
320 ((struct ll_iattr
*)&op_data
->op_attr
)->ia_attr_flags
;
321 if ((op_data
->op_attr
.ia_valid
& ATTR_GID
) &&
322 in_group_p(op_data
->op_attr
.ia_gid
))
324 from_kgid(&init_user_ns
, op_data
->op_attr
.ia_gid
);
326 rec
->sa_suppgid
= op_data
->op_suppgids
[0];
328 rec
->sa_bias
= op_data
->op_bias
;
331 static void mdc_ioepoch_pack(struct mdt_ioepoch
*epoch
,
332 struct md_op_data
*op_data
)
334 memcpy(&epoch
->handle
, &op_data
->op_handle
, sizeof(epoch
->handle
));
335 epoch
->ioepoch
= op_data
->op_ioepoch
;
336 epoch
->flags
= op_data
->op_flags
& MF_SOM_LOCAL_FLAGS
;
339 void mdc_setattr_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
,
340 void *ea
, int ealen
, void *ea2
, int ea2len
)
342 struct mdt_rec_setattr
*rec
;
343 struct mdt_ioepoch
*epoch
;
344 struct lov_user_md
*lum
= NULL
;
346 CLASSERT(sizeof(struct mdt_rec_reint
) ==
347 sizeof(struct mdt_rec_setattr
));
348 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
349 mdc_setattr_pack_rec(rec
, op_data
);
351 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
353 if (op_data
->op_flags
& (MF_SOM_CHANGE
| MF_EPOCH_OPEN
)) {
354 epoch
= req_capsule_client_get(&req
->rq_pill
, &RMF_MDT_EPOCH
);
355 mdc_ioepoch_pack(epoch
, op_data
);
361 lum
= req_capsule_client_get(&req
->rq_pill
, &RMF_EADATA
);
362 if (ea
== NULL
) { /* Remove LOV EA */
363 lum
->lmm_magic
= LOV_USER_MAGIC_V1
;
364 lum
->lmm_stripe_size
= 0;
365 lum
->lmm_stripe_count
= 0;
366 lum
->lmm_stripe_offset
= (typeof(lum
->lmm_stripe_offset
))(-1);
368 memcpy(lum
, ea
, ealen
);
374 memcpy(req_capsule_client_get(&req
->rq_pill
, &RMF_LOGCOOKIES
), ea2
,
378 void mdc_unlink_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
)
380 struct mdt_rec_unlink
*rec
;
383 CLASSERT(sizeof(struct mdt_rec_reint
) == sizeof(struct mdt_rec_unlink
));
384 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
385 LASSERT(rec
!= NULL
);
387 rec
->ul_opcode
= op_data
->op_cli_flags
& CLI_RM_ENTRY
?
388 REINT_RMENTRY
: REINT_UNLINK
;
389 rec
->ul_fsuid
= op_data
->op_fsuid
;
390 rec
->ul_fsgid
= op_data
->op_fsgid
;
391 rec
->ul_cap
= op_data
->op_cap
;
392 rec
->ul_mode
= op_data
->op_mode
;
393 rec
->ul_suppgid1
= op_data
->op_suppgids
[0];
394 rec
->ul_suppgid2
= -1;
395 rec
->ul_fid1
= op_data
->op_fid1
;
396 rec
->ul_fid2
= op_data
->op_fid2
;
397 rec
->ul_time
= op_data
->op_mod_time
;
398 rec
->ul_bias
= op_data
->op_bias
;
400 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
402 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_NAME
);
403 LASSERT(tmp
!= NULL
);
404 LOGL0(op_data
->op_name
, op_data
->op_namelen
, tmp
);
407 void mdc_link_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
)
409 struct mdt_rec_link
*rec
;
412 CLASSERT(sizeof(struct mdt_rec_reint
) == sizeof(struct mdt_rec_link
));
413 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
414 LASSERT(rec
!= NULL
);
416 rec
->lk_opcode
= REINT_LINK
;
417 rec
->lk_fsuid
= op_data
->op_fsuid
; /* current->fsuid; */
418 rec
->lk_fsgid
= op_data
->op_fsgid
; /* current->fsgid; */
419 rec
->lk_cap
= op_data
->op_cap
; /* current->cap_effective; */
420 rec
->lk_suppgid1
= op_data
->op_suppgids
[0];
421 rec
->lk_suppgid2
= op_data
->op_suppgids
[1];
422 rec
->lk_fid1
= op_data
->op_fid1
;
423 rec
->lk_fid2
= op_data
->op_fid2
;
424 rec
->lk_time
= op_data
->op_mod_time
;
425 rec
->lk_bias
= op_data
->op_bias
;
427 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
428 mdc_pack_capa(req
, &RMF_CAPA2
, op_data
->op_capa2
);
430 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_NAME
);
431 LOGL0(op_data
->op_name
, op_data
->op_namelen
, tmp
);
434 void mdc_rename_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
,
435 const char *old
, int oldlen
, const char *new, int newlen
)
437 struct mdt_rec_rename
*rec
;
440 CLASSERT(sizeof(struct mdt_rec_reint
) == sizeof(struct mdt_rec_rename
));
441 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
443 /* XXX do something about time, uid, gid */
444 rec
->rn_opcode
= REINT_RENAME
;
445 rec
->rn_fsuid
= op_data
->op_fsuid
;
446 rec
->rn_fsgid
= op_data
->op_fsgid
;
447 rec
->rn_cap
= op_data
->op_cap
;
448 rec
->rn_suppgid1
= op_data
->op_suppgids
[0];
449 rec
->rn_suppgid2
= op_data
->op_suppgids
[1];
450 rec
->rn_fid1
= op_data
->op_fid1
;
451 rec
->rn_fid2
= op_data
->op_fid2
;
452 rec
->rn_time
= op_data
->op_mod_time
;
453 rec
->rn_mode
= op_data
->op_mode
;
454 rec
->rn_bias
= op_data
->op_bias
;
456 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
457 mdc_pack_capa(req
, &RMF_CAPA2
, op_data
->op_capa2
);
459 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_NAME
);
460 LOGL0(old
, oldlen
, tmp
);
463 tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_SYMTGT
);
464 LOGL0(new, newlen
, tmp
);
468 void mdc_getattr_pack(struct ptlrpc_request
*req
, __u64 valid
, int flags
,
469 struct md_op_data
*op_data
, int ea_size
)
471 struct mdt_body
*b
= req_capsule_client_get(&req
->rq_pill
,
475 if (op_data
->op_bias
& MDS_CHECK_SPLIT
)
476 b
->valid
|= OBD_MD_FLCKSPLIT
;
477 if (op_data
->op_bias
& MDS_CROSS_REF
)
478 b
->valid
|= OBD_MD_FLCROSSREF
;
479 b
->eadatasize
= ea_size
;
481 __mdc_pack_body(b
, op_data
->op_suppgids
[0]);
483 b
->fid1
= op_data
->op_fid1
;
484 b
->fid2
= op_data
->op_fid2
;
485 b
->valid
|= OBD_MD_FLID
;
487 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
489 if (op_data
->op_name
) {
490 char *tmp
= req_capsule_client_get(&req
->rq_pill
, &RMF_NAME
);
492 LOGL0(op_data
->op_name
, op_data
->op_namelen
, tmp
);
497 static void mdc_hsm_release_pack(struct ptlrpc_request
*req
,
498 struct md_op_data
*op_data
)
500 if (op_data
->op_bias
& MDS_HSM_RELEASE
) {
501 struct close_data
*data
;
502 struct ldlm_lock
*lock
;
504 data
= req_capsule_client_get(&req
->rq_pill
, &RMF_CLOSE_DATA
);
505 LASSERT(data
!= NULL
);
507 lock
= ldlm_handle2lock(&op_data
->op_lease_handle
);
509 data
->cd_handle
= lock
->l_remote_handle
;
512 ldlm_cli_cancel(&op_data
->op_lease_handle
, LCF_LOCAL
);
514 data
->cd_data_version
= op_data
->op_data_version
;
515 data
->cd_fid
= op_data
->op_fid2
;
519 void mdc_close_pack(struct ptlrpc_request
*req
, struct md_op_data
*op_data
)
521 struct mdt_ioepoch
*epoch
;
522 struct mdt_rec_setattr
*rec
;
524 epoch
= req_capsule_client_get(&req
->rq_pill
, &RMF_MDT_EPOCH
);
525 rec
= req_capsule_client_get(&req
->rq_pill
, &RMF_REC_REINT
);
527 mdc_setattr_pack_rec(rec
, op_data
);
528 mdc_pack_capa(req
, &RMF_CAPA1
, op_data
->op_capa1
);
529 mdc_ioepoch_pack(epoch
, op_data
);
530 mdc_hsm_release_pack(req
, op_data
);
533 static int mdc_req_avail(struct client_obd
*cli
, struct mdc_cache_waiter
*mcw
)
537 client_obd_list_lock(&cli
->cl_loi_list_lock
);
538 rc
= list_empty(&mcw
->mcw_entry
);
539 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
543 /* We record requests in flight in cli->cl_r_in_flight here.
544 * There is only one write rpc possible in mdc anyway. If this to change
545 * in the future - the code may need to be revisited. */
546 int mdc_enter_request(struct client_obd
*cli
)
549 struct mdc_cache_waiter mcw
;
550 struct l_wait_info lwi
= LWI_INTR(LWI_ON_SIGNAL_NOOP
, NULL
);
552 client_obd_list_lock(&cli
->cl_loi_list_lock
);
553 if (cli
->cl_r_in_flight
>= cli
->cl_max_rpcs_in_flight
) {
554 list_add_tail(&mcw
.mcw_entry
, &cli
->cl_cache_waiters
);
555 init_waitqueue_head(&mcw
.mcw_waitq
);
556 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
557 rc
= l_wait_event(mcw
.mcw_waitq
, mdc_req_avail(cli
, &mcw
),
560 client_obd_list_lock(&cli
->cl_loi_list_lock
);
561 if (list_empty(&mcw
.mcw_entry
))
562 cli
->cl_r_in_flight
--;
563 list_del_init(&mcw
.mcw_entry
);
564 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
567 cli
->cl_r_in_flight
++;
568 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
573 void mdc_exit_request(struct client_obd
*cli
)
575 struct list_head
*l
, *tmp
;
576 struct mdc_cache_waiter
*mcw
;
578 client_obd_list_lock(&cli
->cl_loi_list_lock
);
579 cli
->cl_r_in_flight
--;
580 list_for_each_safe(l
, tmp
, &cli
->cl_cache_waiters
) {
581 if (cli
->cl_r_in_flight
>= cli
->cl_max_rpcs_in_flight
) {
582 /* No free request slots anymore */
586 mcw
= list_entry(l
, struct mdc_cache_waiter
, mcw_entry
);
587 list_del_init(&mcw
->mcw_entry
);
588 cli
->cl_r_in_flight
++;
589 wake_up(&mcw
->mcw_waitq
);
591 /* Empty waiting list? Decrease reqs in-flight number */
593 client_obd_list_unlock(&cli
->cl_loi_list_lock
);
This page took 0.066002 seconds and 5 git commands to generate.