Lines Matching refs:lo
57 static void pnfs_layoutreturn_before_put_layout_hdr(struct pnfs_layout_hdr *lo);
58 static void pnfs_free_returned_lsegs(struct pnfs_layout_hdr *lo,
264 pnfs_get_layout_hdr(struct pnfs_layout_hdr *lo)
266 refcount_inc(&lo->plh_refcount);
277 pnfs_free_layout_hdr(struct pnfs_layout_hdr *lo)
279 struct nfs_server *server = NFS_SERVER(lo->plh_inode);
282 if (test_and_clear_bit(NFS_LAYOUT_HASHED, &lo->plh_flags)) {
286 list_del_rcu(&lo->plh_layouts);
289 put_cred(lo->plh_lc_cred);
290 return ld->free_layout_hdr(lo);
294 pnfs_detach_layout_hdr(struct pnfs_layout_hdr *lo)
296 struct nfs_inode *nfsi = NFS_I(lo->plh_inode);
297 dprintk("%s: freeing layout cache %p\n", __func__, lo);
305 pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo)
310 if (!lo)
312 inode = lo->plh_inode;
313 pnfs_layoutreturn_before_put_layout_hdr(lo);
315 if (refcount_dec_and_lock(&lo->plh_refcount, &inode->i_lock)) {
316 if (!list_empty(&lo->plh_segs))
318 pnfs_detach_layout_hdr(lo);
321 pnfs_free_layout_hdr(lo);
324 wake_up_var(lo);
329 pnfs_grab_inode_layout_hdr(struct pnfs_layout_hdr *lo)
331 struct inode *inode = igrab(lo->plh_inode);
334 set_bit(NFS_LAYOUT_INODE_FREEING, &lo->plh_flags);
347 static void pnfs_barrier_update(struct pnfs_layout_hdr *lo, u32 newseq)
349 if (pnfs_seqid_is_newer(newseq, lo->plh_barrier) || !lo->plh_barrier)
350 lo->plh_barrier = newseq;
354 pnfs_set_plh_return_info(struct pnfs_layout_hdr *lo, enum pnfs_iomode iomode,
357 if (lo->plh_return_iomode != 0 && lo->plh_return_iomode != iomode)
359 lo->plh_return_iomode = iomode;
360 set_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags);
362 * We must set lo->plh_return_seq to avoid livelocks with
366 seq = be32_to_cpu(lo->plh_stateid.seqid);
367 if (!lo->plh_return_seq || pnfs_seqid_is_newer(seq, lo->plh_return_seq))
368 lo->plh_return_seq = seq;
369 pnfs_barrier_update(lo, seq);
373 pnfs_clear_layoutreturn_info(struct pnfs_layout_hdr *lo)
376 lo->plh_return_iomode = 0;
377 lo->plh_return_seq = 0;
378 clear_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags);
379 list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
382 pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0);
386 static void pnfs_clear_layoutreturn_waitbit(struct pnfs_layout_hdr *lo)
388 clear_bit_unlock(NFS_LAYOUT_RETURN, &lo->plh_flags);
389 clear_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags);
391 wake_up_bit(&lo->plh_flags, NFS_LAYOUT_RETURN);
392 rpc_wake_up(&NFS_SERVER(lo->plh_inode)->roc_rpcwaitq);
415 struct pnfs_layout_hdr *lo;
426 lo = NFS_I(inode)->layout;
427 if (lo && pnfs_layout_is_valid(lo) &&
428 nfs4_stateid_match_other(dst, &lo->plh_stateid)) {
430 if (!nfs4_stateid_is_newer(&lo->plh_stateid, dst)) {
436 err = pnfs_mark_matching_lsegs_return(lo, &head, &range, 0);
438 dst->seqid = lo->plh_stateid.seqid;
457 pnfs_mark_layout_stateid_invalid(struct pnfs_layout_hdr *lo,
467 set_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags);
468 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list)
470 pnfs_clear_layoutreturn_info(lo);
471 pnfs_free_returned_lsegs(lo, lseg_list, &range, 0);
472 set_bit(NFS_LAYOUT_DRAIN, &lo->plh_flags);
473 if (test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags) &&
474 !test_and_set_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags))
475 pnfs_clear_layoutreturn_waitbit(lo);
476 return !list_empty(&lo->plh_segs);
487 pnfs_layout_set_fail_bit(struct pnfs_layout_hdr *lo, int fail_bit)
489 lo->plh_retry_timestamp = jiffies;
490 if (!test_and_set_bit(fail_bit, &lo->plh_flags))
491 refcount_inc(&lo->plh_refcount);
495 pnfs_layout_clear_fail_bit(struct pnfs_layout_hdr *lo, int fail_bit)
497 if (test_and_clear_bit(fail_bit, &lo->plh_flags))
498 refcount_dec(&lo->plh_refcount);
502 pnfs_layout_io_set_failed(struct pnfs_layout_hdr *lo, u32 iomode)
504 struct inode *inode = lo->plh_inode;
513 pnfs_layout_set_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode));
514 pnfs_mark_matching_lsegs_return(lo, &head, &range, 0);
522 pnfs_layout_io_test_failed(struct pnfs_layout_hdr *lo, u32 iomode)
527 if (test_bit(fail_bit, &lo->plh_flags) == 0)
531 if (!time_in_range(lo->plh_retry_timestamp, start, end)) {
533 pnfs_layout_clear_fail_bit(lo, fail_bit);
540 pnfs_init_lseg(struct pnfs_layout_hdr *lo, struct pnfs_layout_segment *lseg,
549 lseg->pls_layout = lo;
563 pnfs_layout_remove_lseg(struct pnfs_layout_hdr *lo,
569 refcount_dec(&lo->plh_refcount);
572 if (list_empty(&lo->plh_segs) &&
573 !test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags) &&
574 !test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) {
575 if (atomic_read(&lo->plh_outstanding) == 0)
576 set_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags);
577 clear_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags);
582 pnfs_cache_lseg_for_layoutreturn(struct pnfs_layout_hdr *lo,
586 pnfs_layout_is_valid(lo)) {
587 pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0);
588 list_move_tail(&lseg->pls_list, &lo->plh_return_segs);
597 struct pnfs_layout_hdr *lo;
607 lo = lseg->pls_layout;
608 inode = lo->plh_inode;
611 pnfs_get_layout_hdr(lo);
612 pnfs_layout_remove_lseg(lo, lseg);
613 if (pnfs_cache_lseg_for_layoutreturn(lo, lseg))
617 pnfs_put_layout_hdr(lo);
693 * @lo: layout header containing the lsegs
707 pnfs_mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
713 struct nfs_server *server = NFS_SERVER(lo->plh_inode);
716 dprintk("%s:Begin lo %p\n", __func__, lo);
718 if (list_empty(&lo->plh_segs))
720 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list)
736 pnfs_free_returned_lsegs(struct pnfs_layout_hdr *lo,
743 list_for_each_entry_safe(lseg, next, &lo->plh_return_segs, pls_list) {
766 struct pnfs_layout_hdr *lo;
770 lo = nfsi->layout;
771 if (lo) {
772 pnfs_get_layout_hdr(lo);
773 pnfs_mark_layout_stateid_invalid(lo, &tmp_list);
774 pnfs_layout_clear_fail_bit(lo, NFS_LAYOUT_RO_FAILED);
775 pnfs_layout_clear_fail_bit(lo, NFS_LAYOUT_RW_FAILED);
779 pnfs_put_layout_hdr(lo);
782 return lo;
792 struct pnfs_layout_hdr *lo)
797 ret = nfsi->layout != lo;
804 struct pnfs_layout_hdr *lo = __pnfs_destroy_layout(nfsi);
806 if (lo)
807 wait_var_event(lo, pnfs_layout_removed(nfsi, lo));
814 struct pnfs_layout_hdr *lo;
818 lo = NFS_I(inode)->layout;
819 if (lo != NULL && list_empty(&lo->plh_bulk_destroy)) {
820 pnfs_get_layout_hdr(lo);
821 list_add(&lo->plh_bulk_destroy, layout_list);
836 struct pnfs_layout_hdr *lo, *next;
839 list_for_each_entry_safe(lo, next, &server->layouts, plh_layouts) {
840 if (test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
841 test_bit(NFS_LAYOUT_INODE_FREEING, &lo->plh_flags) ||
842 !list_empty(&lo->plh_bulk_destroy))
847 inode = pnfs_grab_inode_layout_hdr(lo);
849 if (test_and_clear_bit(NFS_LAYOUT_HASHED, &lo->plh_flags))
850 list_del_rcu(&lo->plh_layouts);
873 struct pnfs_layout_hdr *lo;
879 lo = list_entry(layout_list->next, struct pnfs_layout_hdr,
882 lo->plh_inode->i_ino);
883 inode = lo->plh_inode;
888 list_del_init(&lo->plh_bulk_destroy);
889 if (pnfs_mark_layout_stateid_invalid(lo, &lseg_list)) {
891 set_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags);
898 pnfs_put_layout_hdr(lo);
969 pnfs_set_layout_cred(struct pnfs_layout_hdr *lo, const struct cred *cred)
973 if (cred && cred_fscmp(lo->plh_lc_cred, cred) != 0) {
974 old = xchg(&lo->plh_lc_cred, get_cred(cred));
979 /* update lo->plh_stateid with new if is more recent */
981 pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new,
984 u32 oldseq = be32_to_cpu(lo->plh_stateid.seqid);
987 if (!pnfs_layout_is_valid(lo)) {
988 pnfs_set_layout_cred(lo, cred);
989 nfs4_stateid_copy(&lo->plh_stateid, new);
990 lo->plh_barrier = newseq;
991 pnfs_clear_layoutreturn_info(lo);
992 clear_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags);
997 nfs4_stateid_copy(&lo->plh_stateid, new);
1000 pnfs_barrier_update(lo, newseq);
1008 if (atomic_read(&lo->plh_outstanding) == 1)
1009 pnfs_barrier_update(lo, be32_to_cpu(lo->plh_stateid.seqid));
1013 pnfs_layout_stateid_blocked(const struct pnfs_layout_hdr *lo,
1018 return lo->plh_barrier && pnfs_seqid_is_newer(lo->plh_barrier, seqid);
1023 pnfs_layoutgets_blocked(const struct pnfs_layout_hdr *lo)
1025 return lo->plh_block_lgets ||
1026 test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags);
1146 pnfs_put_layout_hdr(lgp->lo);
1166 void pnfs_layoutreturn_free_lsegs(struct pnfs_layout_hdr *lo,
1171 struct inode *inode = lo->plh_inode;
1175 if (!pnfs_layout_is_valid(lo) ||
1176 !nfs4_stateid_match_other(&lo->plh_stateid, arg_stateid))
1181 pnfs_mark_matching_lsegs_invalid(lo, &freeme, range, seq);
1182 pnfs_free_returned_lsegs(lo, &freeme, range, seq);
1183 pnfs_set_layout_stateid(lo, stateid, NULL, true);
1185 pnfs_mark_layout_stateid_invalid(lo, &freeme);
1187 pnfs_clear_layoutreturn_waitbit(lo);
1194 pnfs_prepare_layoutreturn(struct pnfs_layout_hdr *lo,
1200 if (atomic_read(&lo->plh_outstanding) != 0)
1202 if (test_and_set_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags))
1204 set_bit(NFS_LAYOUT_RETURN, &lo->plh_flags);
1205 pnfs_get_layout_hdr(lo);
1206 nfs4_stateid_copy(stateid, &lo->plh_stateid);
1207 *cred = get_cred(lo->plh_lc_cred);
1208 if (test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags)) {
1209 if (lo->plh_return_seq != 0)
1210 stateid->seqid = cpu_to_be32(lo->plh_return_seq);
1212 *iomode = lo->plh_return_iomode;
1213 pnfs_clear_layoutreturn_info(lo);
1216 pnfs_barrier_update(lo, be32_to_cpu(stateid->seqid));
1222 struct pnfs_layout_hdr *lo,
1226 struct inode *inode = lo->plh_inode;
1233 args->layout = lo;
1238 pnfs_send_layoutreturn(struct pnfs_layout_hdr *lo,
1244 struct inode *ino = lo->plh_inode;
1255 pnfs_clear_layoutreturn_waitbit(lo);
1258 pnfs_put_layout_hdr(lo);
1262 pnfs_init_layoutreturn_args(&lrp->args, lo, stateid, iomode);
1276 pnfs_layout_segments_returnable(struct pnfs_layout_hdr *lo,
1284 return pnfs_mark_matching_lsegs_return(lo, &lo->plh_return_segs,
1290 pnfs_layout_need_return(struct pnfs_layout_hdr *lo)
1292 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags))
1294 return pnfs_layout_segments_returnable(lo, lo->plh_return_iomode,
1295 lo->plh_return_seq);
1298 static void pnfs_layoutreturn_before_put_layout_hdr(struct pnfs_layout_hdr *lo)
1300 struct inode *inode= lo->plh_inode;
1302 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags))
1305 if (pnfs_layout_need_return(lo)) {
1311 send = pnfs_prepare_layoutreturn(lo, &stateid, &cred, &iomode);
1315 pnfs_send_layoutreturn(lo, &stateid, &cred, iomode, false);
1332 struct pnfs_layout_hdr *lo = NULL;
1348 lo = nfsi->layout;
1349 if (!lo) {
1355 pnfs_get_layout_hdr(lo);
1357 if (test_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags)) {
1359 if (wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN,
1364 valid_layout = pnfs_layout_is_valid(lo);
1366 pnfs_mark_matching_lsegs_return(lo, &tmp_list, &range, 0);
1369 NFS_SERVER(ino)->pnfs_curr_ld->return_range(lo, &range);
1372 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags) ||
1379 send = pnfs_prepare_layoutreturn(lo, &stateid, &cred, NULL);
1382 status = pnfs_send_layoutreturn(lo, &stateid, &cred, IOMODE_ANY, true);
1384 wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN, TASK_UNINTERRUPTIBLE);
1387 pnfs_put_layout_hdr(lo);
1396 struct pnfs_layout_hdr *lo;
1400 lo = NFS_I(inode)->layout;
1401 if (lo == NULL) {
1405 pnfs_get_layout_hdr(lo);
1407 lo->plh_block_lgets++;
1414 lo->plh_block_lgets--;
1416 pnfs_put_layout_hdr(lo);
1428 struct pnfs_layout_hdr *lo;
1441 lo = nfsi->layout;
1442 if (!lo || !pnfs_layout_is_valid(lo) ||
1443 test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) {
1444 lo = NULL;
1447 pnfs_get_layout_hdr(lo);
1448 if (test_bit(NFS_LAYOUT_RETURN_LOCK, &lo->plh_flags)) {
1451 wait_on_bit(&lo->plh_flags, NFS_LAYOUT_RETURN,
1453 pnfs_put_layout_hdr(lo);
1476 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list) {
1487 if (!mark_lseg_invalid(lseg, &lo->plh_return_segs))
1489 pnfs_set_plh_return_info(lo, lseg->pls_range.iomode, 0);
1492 if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags))
1499 /* lo ref dropped in pnfs_roc_release() */
1500 layoutreturn = pnfs_prepare_layoutreturn(lo, &stateid, &lc_cred, &iomode);
1506 pnfs_init_layoutreturn_args(args, lo, &stateid, iomode);
1519 pnfs_put_layout_hdr(lo);
1523 pnfs_send_layoutreturn(lo, &stateid, &lc_cred, iomode, true);
1524 pnfs_put_layout_hdr(lo);
1576 struct pnfs_layout_hdr *lo = args->layout;
1584 if (pnfs_layout_is_valid(lo) &&
1585 nfs4_stateid_match_other(&args->stateid, &lo->plh_stateid))
1586 pnfs_set_plh_return_info(lo, args->range.iomode, 0);
1587 pnfs_clear_layoutreturn_waitbit(lo);
1595 pnfs_layoutreturn_free_lsegs(lo, &args->stateid, &args->range,
1601 pnfs_put_layout_hdr(lo);
1607 struct pnfs_layout_hdr *lo;
1610 /* we might not have grabbed lo reference. so need to check under
1613 lo = nfsi->layout;
1614 if (lo && test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) {
1662 pnfs_generic_layout_insert_lseg(struct pnfs_layout_hdr *lo,
1674 list_for_each_entry_safe(lp, tmp, &lo->plh_segs, pls_list) {
1693 list_add_tail(&lseg->pls_list, &lo->plh_segs);
1699 pnfs_get_layout_hdr(lo);
1706 pnfs_layout_insert_lseg(struct pnfs_layout_hdr *lo,
1710 struct inode *inode = lo->plh_inode;
1714 ld->add_lseg(lo, lseg, free_me);
1716 pnfs_generic_layout_insert_lseg(lo, lseg,
1727 struct pnfs_layout_hdr *lo;
1729 lo = pnfs_alloc_layout_hdr(ino, gfp_flags);
1730 if (!lo)
1732 refcount_set(&lo->plh_refcount, 1);
1733 INIT_LIST_HEAD(&lo->plh_layouts);
1734 INIT_LIST_HEAD(&lo->plh_segs);
1735 INIT_LIST_HEAD(&lo->plh_return_segs);
1736 INIT_LIST_HEAD(&lo->plh_bulk_destroy);
1737 lo->plh_inode = ino;
1738 lo->plh_lc_cred = get_cred(ctx->cred);
1739 lo->plh_flags |= 1 << NFS_LAYOUT_INVALID_STID;
1740 return lo;
1808 pnfs_find_lseg(struct pnfs_layout_hdr *lo,
1816 list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
1905 static int pnfs_prepare_to_retry_layoutget(struct pnfs_layout_hdr *lo)
1911 pnfs_layoutcommit_inode(lo->plh_inode, false);
1912 return wait_on_bit_action(&lo->plh_flags, NFS_LAYOUT_RETURN,
1917 static void nfs_layoutget_begin(struct pnfs_layout_hdr *lo)
1919 atomic_inc(&lo->plh_outstanding);
1922 static void nfs_layoutget_end(struct pnfs_layout_hdr *lo)
1924 if (atomic_dec_and_test(&lo->plh_outstanding) &&
1925 test_and_clear_bit(NFS_LAYOUT_DRAIN, &lo->plh_flags))
1926 wake_up_bit(&lo->plh_flags, NFS_LAYOUT_DRAIN);
1929 static bool pnfs_is_first_layoutget(struct pnfs_layout_hdr *lo)
1931 return test_bit(NFS_LAYOUT_FIRST_LAYOUTGET, &lo->plh_flags);
1934 static void pnfs_clear_first_layoutget(struct pnfs_layout_hdr *lo)
1936 unsigned long *bitlock = &lo->plh_flags;
1943 static void _add_to_server_list(struct pnfs_layout_hdr *lo,
1946 if (!test_and_set_bit(NFS_LAYOUT_HASHED, &lo->plh_flags)) {
1949 /* The lo must be on the clp list if there is any
1953 list_add_tail_rcu(&lo->plh_layouts, &server->layouts);
1979 struct pnfs_layout_hdr *lo = NULL;
1988 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
1994 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2005 lo = pnfs_find_alloc_layout(ino, ctx, gfp_flags);
2006 if (lo == NULL) {
2009 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2015 if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) {
2016 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2023 if (pnfs_layout_io_test_failed(lo, iomode)) {
2024 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2033 if (test_bit(NFS_LAYOUT_DRAIN, &lo->plh_flags) &&
2034 atomic_read(&lo->plh_outstanding) != 0) {
2036 lseg = ERR_PTR(wait_on_bit(&lo->plh_flags, NFS_LAYOUT_DRAIN,
2040 pnfs_put_layout_hdr(lo);
2048 if (test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags)) {
2051 lseg = ERR_PTR(pnfs_prepare_to_retry_layoutget(lo));
2053 pnfs_put_layout_hdr(lo);
2055 trace_pnfs_update_layout(ino, pos, count, iomode, lo,
2060 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2065 lseg = pnfs_find_lseg(lo, &arg, strict_iomode);
2067 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2077 if (test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags)) {
2085 &lo->plh_flags)) {
2087 lseg = ERR_PTR(wait_on_bit(&lo->plh_flags,
2092 pnfs_put_layout_hdr(lo);
2105 iomode, lo, lseg,
2108 pnfs_clear_first_layoutget(lo);
2109 pnfs_put_layout_hdr(lo);
2114 nfs4_stateid_copy(&stateid, &lo->plh_stateid);
2117 if (pnfs_layoutgets_blocked(lo)) {
2118 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2122 nfs_layoutget_begin(lo);
2125 _add_to_server_list(lo, server);
2138 trace_pnfs_update_layout(ino, pos, count, iomode, lo, NULL,
2140 nfs_layoutget_end(lo);
2144 lgp->lo = lo;
2145 pnfs_get_layout_hdr(lo);
2148 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2150 nfs_layoutget_end(lo);
2163 lo, pnfs_iomode_to_fail_bit(iomode));
2168 pnfs_layout_clear_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode));
2175 pnfs_clear_first_layoutget(lo);
2177 iomode, lo, lseg, PNFS_UPDATE_LAYOUT_RETRY);
2178 pnfs_put_layout_hdr(lo);
2182 pnfs_layout_clear_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode));
2187 pnfs_clear_first_layoutget(lo);
2188 trace_pnfs_update_layout(ino, pos, count, iomode, lo, lseg,
2190 pnfs_put_layout_hdr(lo);
2230 struct pnfs_layout_hdr *lo;
2233 lo = pnfs_find_alloc_layout(ino, ctx, nfs_io_gfp_mask());
2234 if (!lo)
2236 if (!test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags))
2238 if (test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags))
2240 if (pnfs_layoutgets_blocked(lo))
2242 if (test_and_set_bit(NFS_LAYOUT_FIRST_LAYOUTGET, &lo->plh_flags))
2244 nfs_layoutget_begin(lo);
2246 _add_to_server_list(lo, NFS_SERVER(ino));
2247 return lo;
2251 pnfs_put_layout_hdr(lo);
2266 struct pnfs_layout_hdr *lo;
2273 lo = _pnfs_grab_empty_layout(ino, ctx);
2274 if (!lo)
2279 pnfs_clear_first_layoutget(lo);
2280 nfs_layoutget_end(lo);
2281 pnfs_put_layout_hdr(lo);
2284 lgp->lo = lo;
2333 struct pnfs_layout_hdr *lo;
2363 if (!lgp->lo) {
2364 lo = _pnfs_grab_empty_layout(ino, ctx);
2365 if (!lo)
2367 lgp->lo = lo;
2369 lo = lgp->lo;
2374 pnfs_layout_clear_fail_bit(lo, pnfs_iomode_to_fail_bit(iomode));
2382 if (lgp->lo) {
2383 pnfs_clear_first_layoutget(lgp->lo);
2384 nfs_layoutget_end(lgp->lo);
2393 struct pnfs_layout_hdr *lo = lgp->lo;
2396 struct inode *ino = lo->plh_inode;
2403 lseg = NFS_SERVER(ino)->pnfs_curr_ld->alloc_lseg(lo, res, lgp->gfp_flags);
2413 pnfs_init_lseg(lo, lseg, &res->range, &res->stateid);
2416 if (pnfs_layoutgets_blocked(lo)) {
2421 if (test_bit(NFS_LAYOUT_DRAIN, &lo->plh_flags) &&
2422 !pnfs_is_first_layoutget(lo))
2425 if (nfs4_stateid_match_other(&lo->plh_stateid, &res->stateid)) {
2427 if (pnfs_layout_stateid_blocked(lo, &res->stateid)) {
2428 if (!pnfs_layout_is_valid(lo))
2429 lo->plh_barrier = 0;
2433 pnfs_set_layout_stateid(lo, &res->stateid, lgp->cred, false);
2434 } else if (pnfs_layout_is_valid(lo)) {
2443 pnfs_mark_matching_lsegs_return(lo, &free_me, &range, 0);
2447 pnfs_set_layout_stateid(lo, &res->stateid, lgp->cred, true);
2451 pnfs_layout_insert_lseg(lo, lseg, &free_me);
2463 lseg->pls_layout = lo;
2470 * @lo: pointer to layout header
2485 pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo,
2491 struct nfs_server *server = NFS_SERVER(lo->plh_inode);
2494 dprintk("%s:Begin lo %p\n", __func__, lo);
2496 assert_spin_locked(&lo->plh_inode->i_lock);
2498 if (test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags))
2499 tmp_list = &lo->plh_return_segs;
2501 list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list)
2509 tmp_list = &lo->plh_return_segs;
2518 pnfs_set_plh_return_info(lo, return_range->iomode, seq);
2522 if (!list_empty(&lo->plh_return_segs)) {
2523 pnfs_set_plh_return_info(lo, return_range->iomode, seq);
2534 struct pnfs_layout_hdr *lo;
2538 lo = NFS_I(inode)->layout;
2539 if (!pnfs_layout_is_valid(lo)) {
2543 pnfs_set_plh_return_info(lo, range->iomode, 0);
2549 if (pnfs_mark_matching_lsegs_return(lo, &lo->plh_return_segs, range, 0) != -EBUSY) {
2554 return_now = pnfs_prepare_layoutreturn(lo, &stateid, &cred, &iomode);
2557 pnfs_send_layoutreturn(lo, &stateid, &cred, iomode, false);
2578 pnfs_layout_can_be_returned(struct pnfs_layout_hdr *lo)
2580 return pnfs_layout_is_valid(lo) &&
2581 !test_bit(NFS_LAYOUT_INODE_FREEING, &lo->plh_flags) &&
2582 !test_bit(NFS_LAYOUT_RETURN, &lo->plh_flags);
2586 pnfs_find_first_lseg(struct pnfs_layout_hdr *lo,
2592 list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
2607 pnfs_should_return_unused_layout(struct pnfs_layout_hdr *lo,
2614 if (!pnfs_layout_can_be_returned(lo) ||
2615 !pnfs_find_first_lseg(lo, range, range->iomode))
2618 head = &NFS_I(lo->plh_inode)->open_files;
2631 if (pnfs_find_first_lseg(lo, range, IOMODE_READ))
2642 struct pnfs_layout_hdr *lo;
2649 list_for_each_entry_rcu(lo, &server->layouts, plh_layouts) {
2650 inode = lo->plh_inode;
2651 if (!inode || !pnfs_layout_can_be_returned(lo) ||
2652 test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags))
2655 if (!lo->plh_inode ||
2656 !pnfs_should_return_unused_layout(lo, range)) {
2660 pnfs_get_layout_hdr(lo);
2661 pnfs_set_plh_return_info(lo, range->iomode, 0);
2662 if (pnfs_mark_matching_lsegs_return(lo, &lo->plh_return_segs,
2664 !pnfs_prepare_layoutreturn(lo, &stateid, &cred, &iomode)) {
2667 pnfs_put_layout_hdr(lo);
2673 pnfs_send_layoutreturn(lo, &stateid, &cred, iomode, false);
2674 pnfs_put_layout_hdr(lo);