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.sun.com/software/products/lustre/docs/GPLv2.pdf 19 * 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 22 * have any questions. 23 * 24 * GPL HEADER END 25 */ 26/* 27 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 28 * Use is subject to license terms. 29 * 30 * Copyright (c) 2010, 2012, Intel Corporation. 31 */ 32/* 33 * This file is part of Lustre, http://www.lustre.org/ 34 * Lustre is a trademark of Sun Microsystems, Inc. 35 */ 36 37/** \defgroup LDLM Lustre Distributed Lock Manager 38 * 39 * Lustre DLM is based on VAX DLM. 40 * Its two main roles are: 41 * - To provide locking assuring consistency of data on all Lustre nodes. 42 * - To allow clients to cache state protected by a lock by holding the 43 * lock until a conflicting lock is requested or it is expired by the LRU. 44 * 45 * @{ 46 */ 47 48#ifndef _LUSTRE_DLM_H__ 49#define _LUSTRE_DLM_H__ 50 51#include "lustre_lib.h" 52#include "lustre_net.h" 53#include "lustre_import.h" 54#include "lustre_handles.h" 55#include "interval_tree.h" /* for interval_node{}, ldlm_extent */ 56#include "lu_ref.h" 57 58#include "lustre_dlm_flags.h" 59 60struct obd_ops; 61struct obd_device; 62 63#define OBD_LDLM_DEVICENAME "ldlm" 64 65#define LDLM_DEFAULT_LRU_SIZE (100 * num_online_cpus()) 66#define LDLM_DEFAULT_MAX_ALIVE (cfs_time_seconds(36000)) 67#define LDLM_CTIME_AGE_LIMIT (10) 68#define LDLM_DEFAULT_PARALLEL_AST_LIMIT 1024 69 70/** 71 * LDLM non-error return states 72 */ 73typedef enum { 74 ELDLM_OK = 0, 75 76 ELDLM_LOCK_CHANGED = 300, 77 ELDLM_LOCK_ABORTED = 301, 78 ELDLM_LOCK_REPLACED = 302, 79 ELDLM_NO_LOCK_DATA = 303, 80 ELDLM_LOCK_WOULDBLOCK = 304, 81 82 ELDLM_NAMESPACE_EXISTS = 400, 83 ELDLM_BAD_NAMESPACE = 401 84} ldlm_error_t; 85 86/** 87 * LDLM namespace type. 88 * The "client" type is actually an indication that this is a narrow local view 89 * into complete namespace on the server. Such namespaces cannot make any 90 * decisions about lack of conflicts or do any autonomous lock granting without 91 * first speaking to a server. 92 */ 93typedef enum { 94 LDLM_NAMESPACE_SERVER = 1 << 0, 95 LDLM_NAMESPACE_CLIENT = 1 << 1 96} ldlm_side_t; 97 98/** 99 * The blocking callback is overloaded to perform two functions. These flags 100 * indicate which operation should be performed. 101 */ 102#define LDLM_CB_BLOCKING 1 103#define LDLM_CB_CANCELING 2 104 105/** 106 * \name Lock Compatibility Matrix. 107 * 108 * A lock has both a type (extent, flock, inode bits, or plain) and a mode. 109 * Lock types are described in their respective implementation files: 110 * ldlm_{extent,flock,inodebits,plain}.c. 111 * 112 * There are six lock modes along with a compatibility matrix to indicate if 113 * two locks are compatible. 114 * 115 * - EX: Exclusive mode. Before a new file is created, MDS requests EX lock 116 * on the parent. 117 * - PW: Protective Write (normal write) mode. When a client requests a write 118 * lock from an OST, a lock with PW mode will be issued. 119 * - PR: Protective Read (normal read) mode. When a client requests a read from 120 * an OST, a lock with PR mode will be issued. Also, if the client opens a 121 * file for execution, it is granted a lock with PR mode. 122 * - CW: Concurrent Write mode. The type of lock that the MDS grants if a client 123 * requests a write lock during a file open operation. 124 * - CR Concurrent Read mode. When a client performs a path lookup, MDS grants 125 * an inodebit lock with the CR mode on the intermediate path component. 126 * - NL Null mode. 127 * 128 * <PRE> 129 * NL CR CW PR PW EX 130 * NL 1 1 1 1 1 1 131 * CR 1 1 1 1 1 0 132 * CW 1 1 1 0 0 0 133 * PR 1 1 0 1 0 0 134 * PW 1 1 0 0 0 0 135 * EX 1 0 0 0 0 0 136 * </PRE> 137 */ 138/** @{ */ 139#define LCK_COMPAT_EX LCK_NL 140#define LCK_COMPAT_PW (LCK_COMPAT_EX | LCK_CR) 141#define LCK_COMPAT_PR (LCK_COMPAT_PW | LCK_PR) 142#define LCK_COMPAT_CW (LCK_COMPAT_PW | LCK_CW) 143#define LCK_COMPAT_CR (LCK_COMPAT_CW | LCK_PR | LCK_PW) 144#define LCK_COMPAT_NL (LCK_COMPAT_CR | LCK_EX | LCK_GROUP) 145#define LCK_COMPAT_GROUP (LCK_GROUP | LCK_NL) 146#define LCK_COMPAT_COS (LCK_COS) 147/** @} Lock Compatibility Matrix */ 148 149extern ldlm_mode_t lck_compat_array[]; 150 151static inline void lockmode_verify(ldlm_mode_t mode) 152{ 153 LASSERT(mode > LCK_MINMODE && mode < LCK_MAXMODE); 154} 155 156static inline int lockmode_compat(ldlm_mode_t exist_mode, ldlm_mode_t new_mode) 157{ 158 return (lck_compat_array[exist_mode] & new_mode); 159} 160 161/* 162 * 163 * cluster name spaces 164 * 165 */ 166 167#define DLM_OST_NAMESPACE 1 168#define DLM_MDS_NAMESPACE 2 169 170/* XXX 171 - do we just separate this by security domains and use a prefix for 172 multiple namespaces in the same domain? 173 - 174*/ 175 176/** 177 * Locking rules for LDLM: 178 * 179 * lr_lock 180 * 181 * lr_lock 182 * waiting_locks_spinlock 183 * 184 * lr_lock 185 * led_lock 186 * 187 * lr_lock 188 * ns_lock 189 * 190 * lr_lvb_mutex 191 * lr_lock 192 * 193 */ 194 195struct ldlm_pool; 196struct ldlm_lock; 197struct ldlm_resource; 198struct ldlm_namespace; 199 200/** 201 * Operations on LDLM pools. 202 * LDLM pool is a pool of locks in the namespace without any implicitly 203 * specified limits. 204 * Locks in the pool are organized in LRU. 205 * Local memory pressure or server instructions (e.g. mempressure on server) 206 * can trigger freeing of locks from the pool 207 */ 208struct ldlm_pool_ops { 209 /** Recalculate pool \a pl usage */ 210 int (*po_recalc)(struct ldlm_pool *pl); 211 /** Cancel at least \a nr locks from pool \a pl */ 212 int (*po_shrink)(struct ldlm_pool *pl, int nr, 213 gfp_t gfp_mask); 214 int (*po_setup)(struct ldlm_pool *pl, int limit); 215}; 216 217/** One second for pools thread check interval. Each pool has own period. */ 218#define LDLM_POOLS_THREAD_PERIOD (1) 219 220/** ~6% margin for modest pools. See ldlm_pool.c for details. */ 221#define LDLM_POOLS_MODEST_MARGIN_SHIFT (4) 222 223/** Default recalc period for server side pools in sec. */ 224#define LDLM_POOL_SRV_DEF_RECALC_PERIOD (1) 225 226/** Default recalc period for client side pools in sec. */ 227#define LDLM_POOL_CLI_DEF_RECALC_PERIOD (10) 228 229/** 230 * LDLM pool structure to track granted locks. 231 * For purposes of determining when to release locks on e.g. memory pressure. 232 * This feature is commonly referred to as lru_resize. 233 */ 234struct ldlm_pool { 235 /** Pool proc directory. */ 236 struct proc_dir_entry *pl_proc_dir; 237 /** Pool name, must be long enough to hold compound proc entry name. */ 238 char pl_name[100]; 239 /** Lock for protecting SLV/CLV updates. */ 240 spinlock_t pl_lock; 241 /** Number of allowed locks in in pool, both, client and server side. */ 242 atomic_t pl_limit; 243 /** Number of granted locks in */ 244 atomic_t pl_granted; 245 /** Grant rate per T. */ 246 atomic_t pl_grant_rate; 247 /** Cancel rate per T. */ 248 atomic_t pl_cancel_rate; 249 /** Server lock volume (SLV). Protected by pl_lock. */ 250 __u64 pl_server_lock_volume; 251 /** Current biggest client lock volume. Protected by pl_lock. */ 252 __u64 pl_client_lock_volume; 253 /** Lock volume factor. SLV on client is calculated as following: 254 * server_slv * lock_volume_factor. */ 255 atomic_t pl_lock_volume_factor; 256 /** Time when last SLV from server was obtained. */ 257 time_t pl_recalc_time; 258 /** Recalculation period for pool. */ 259 time_t pl_recalc_period; 260 /** Recalculation and shrink operations. */ 261 const struct ldlm_pool_ops *pl_ops; 262 /** Number of planned locks for next period. */ 263 int pl_grant_plan; 264 /** Pool statistics. */ 265 struct lprocfs_stats *pl_stats; 266}; 267 268typedef int (*ldlm_res_policy)(struct ldlm_namespace *, struct ldlm_lock **, 269 void *req_cookie, ldlm_mode_t mode, __u64 flags, 270 void *data); 271 272typedef int (*ldlm_cancel_for_recovery)(struct ldlm_lock *lock); 273 274/** 275 * LVB operations. 276 * LVB is Lock Value Block. This is a special opaque (to LDLM) value that could 277 * be associated with an LDLM lock and transferred from client to server and 278 * back. 279 * 280 * Currently LVBs are used by: 281 * - OSC-OST code to maintain current object size/times 282 * - layout lock code to return the layout when the layout lock is granted 283 */ 284struct ldlm_valblock_ops { 285 int (*lvbo_init)(struct ldlm_resource *res); 286 int (*lvbo_update)(struct ldlm_resource *res, 287 struct ptlrpc_request *r, 288 int increase); 289 int (*lvbo_free)(struct ldlm_resource *res); 290 /* Return size of lvb data appropriate RPC size can be reserved */ 291 int (*lvbo_size)(struct ldlm_lock *lock); 292 /* Called to fill in lvb data to RPC buffer @buf */ 293 int (*lvbo_fill)(struct ldlm_lock *lock, void *buf, int buflen); 294}; 295 296/** 297 * LDLM pools related, type of lock pool in the namespace. 298 * Greedy means release cached locks aggressively 299 */ 300typedef enum { 301 LDLM_NAMESPACE_GREEDY = 1 << 0, 302 LDLM_NAMESPACE_MODEST = 1 << 1 303} ldlm_appetite_t; 304 305/** 306 * Default values for the "max_nolock_size", "contention_time" and 307 * "contended_locks" namespace tunables. 308 */ 309#define NS_DEFAULT_MAX_NOLOCK_BYTES 0 310#define NS_DEFAULT_CONTENTION_SECONDS 2 311#define NS_DEFAULT_CONTENDED_LOCKS 32 312 313struct ldlm_ns_bucket { 314 /** back pointer to namespace */ 315 struct ldlm_namespace *nsb_namespace; 316 /** 317 * Estimated lock callback time. Used by adaptive timeout code to 318 * avoid spurious client evictions due to unresponsiveness when in 319 * fact the network or overall system load is at fault 320 */ 321 struct adaptive_timeout nsb_at_estimate; 322}; 323 324enum { 325 /** LDLM namespace lock stats */ 326 LDLM_NSS_LOCKS = 0, 327 LDLM_NSS_LAST 328}; 329 330typedef enum { 331 /** invalid type */ 332 LDLM_NS_TYPE_UNKNOWN = 0, 333 /** mdc namespace */ 334 LDLM_NS_TYPE_MDC, 335 /** mds namespace */ 336 LDLM_NS_TYPE_MDT, 337 /** osc namespace */ 338 LDLM_NS_TYPE_OSC, 339 /** ost namespace */ 340 LDLM_NS_TYPE_OST, 341 /** mgc namespace */ 342 LDLM_NS_TYPE_MGC, 343 /** mgs namespace */ 344 LDLM_NS_TYPE_MGT, 345} ldlm_ns_type_t; 346 347/** 348 * LDLM Namespace. 349 * 350 * Namespace serves to contain locks related to a particular service. 351 * There are two kinds of namespaces: 352 * - Server namespace has knowledge of all locks and is therefore authoritative 353 * to make decisions like what locks could be granted and what conflicts 354 * exist during new lock enqueue. 355 * - Client namespace only has limited knowledge about locks in the namespace, 356 * only seeing locks held by the client. 357 * 358 * Every Lustre service has one server namespace present on the server serving 359 * that service. Every client connected to the service has a client namespace 360 * for it. 361 * Every lock obtained by client in that namespace is actually represented by 362 * two in-memory locks. One on the server and one on the client. The locks are 363 * linked by a special cookie by which one node can tell to the other which lock 364 * it actually means during communications. Such locks are called remote locks. 365 * The locks held by server only without any reference to a client are called 366 * local locks. 367 */ 368struct ldlm_namespace { 369 /** Backward link to OBD, required for LDLM pool to store new SLV. */ 370 struct obd_device *ns_obd; 371 372 /** Flag indicating if namespace is on client instead of server */ 373 ldlm_side_t ns_client; 374 375 /** Resource hash table for namespace. */ 376 struct cfs_hash *ns_rs_hash; 377 378 /** serialize */ 379 spinlock_t ns_lock; 380 381 /** big refcount (by bucket) */ 382 atomic_t ns_bref; 383 384 /** 385 * Namespace connect flags supported by server (may be changed via 386 * /proc, LRU resize may be disabled/enabled). 387 */ 388 __u64 ns_connect_flags; 389 390 /** Client side original connect flags supported by server. */ 391 __u64 ns_orig_connect_flags; 392 393 /* namespace proc dir entry */ 394 struct proc_dir_entry *ns_proc_dir_entry; 395 396 /** 397 * Position in global namespace list linking all namespaces on 398 * the node. 399 */ 400 struct list_head ns_list_chain; 401 402 /** 403 * List of unused locks for this namespace. This list is also called 404 * LRU lock list. 405 * Unused locks are locks with zero reader/writer reference counts. 406 * This list is only used on clients for lock caching purposes. 407 * When we want to release some locks voluntarily or if server wants 408 * us to release some locks due to e.g. memory pressure, we take locks 409 * to release from the head of this list. 410 * Locks are linked via l_lru field in \see struct ldlm_lock. 411 */ 412 struct list_head ns_unused_list; 413 /** Number of locks in the LRU list above */ 414 int ns_nr_unused; 415 416 /** 417 * Maximum number of locks permitted in the LRU. If 0, means locks 418 * are managed by pools and there is no preset limit, rather it is all 419 * controlled by available memory on this client and on server. 420 */ 421 unsigned int ns_max_unused; 422 /** Maximum allowed age (last used time) for locks in the LRU */ 423 unsigned int ns_max_age; 424 /** 425 * Server only: number of times we evicted clients due to lack of reply 426 * to ASTs. 427 */ 428 unsigned int ns_timeouts; 429 /** 430 * Number of seconds since the file change time after which the 431 * MDT will return an UPDATE lock along with a LOOKUP lock. 432 * This allows the client to start caching negative dentries 433 * for a directory and may save an RPC for a later stat. 434 */ 435 unsigned int ns_ctime_age_limit; 436 437 /** 438 * Used to rate-limit ldlm_namespace_dump calls. 439 * \see ldlm_namespace_dump. Increased by 10 seconds every time 440 * it is called. 441 */ 442 unsigned long ns_next_dump; 443 444 /** "policy" function that does actual lock conflict determination */ 445 ldlm_res_policy ns_policy; 446 447 /** 448 * LVB operations for this namespace. 449 * \see struct ldlm_valblock_ops 450 */ 451 struct ldlm_valblock_ops *ns_lvbo; 452 453 /** 454 * Used by filter code to store pointer to OBD of the service. 455 * Should be dropped in favor of \a ns_obd 456 */ 457 void *ns_lvbp; 458 459 /** 460 * Wait queue used by __ldlm_namespace_free. Gets woken up every time 461 * a resource is removed. 462 */ 463 wait_queue_head_t ns_waitq; 464 /** LDLM pool structure for this namespace */ 465 struct ldlm_pool ns_pool; 466 /** Definition of how eagerly unused locks will be released from LRU */ 467 ldlm_appetite_t ns_appetite; 468 469 /** 470 * If more than \a ns_contended_locks are found, the resource is 471 * considered to be contended. Lock enqueues might specify that no 472 * contended locks should be granted 473 */ 474 unsigned ns_contended_locks; 475 476 /** 477 * The resources in this namespace remember contended state during 478 * \a ns_contention_time, in seconds. 479 */ 480 unsigned ns_contention_time; 481 482 /** 483 * Limit size of contended extent locks, in bytes. 484 * If extended lock is requested for more then this many bytes and 485 * caller instructs us not to grant contended locks, we would disregard 486 * such a request. 487 */ 488 unsigned ns_max_nolock_size; 489 490 /** Limit of parallel AST RPC count. */ 491 unsigned ns_max_parallel_ast; 492 493 /** Callback to cancel locks before replaying it during recovery. */ 494 ldlm_cancel_for_recovery ns_cancel_for_recovery; 495 496 /** LDLM lock stats */ 497 struct lprocfs_stats *ns_stats; 498 499 /** 500 * Flag to indicate namespace is being freed. Used to determine if 501 * recalculation of LDLM pool statistics should be skipped. 502 */ 503 unsigned ns_stopping:1; 504}; 505 506/** 507 * Returns 1 if namespace \a ns is a client namespace. 508 */ 509static inline int ns_is_client(struct ldlm_namespace *ns) 510{ 511 LASSERT(ns != NULL); 512 LASSERT(!(ns->ns_client & ~(LDLM_NAMESPACE_CLIENT | 513 LDLM_NAMESPACE_SERVER))); 514 LASSERT(ns->ns_client == LDLM_NAMESPACE_CLIENT || 515 ns->ns_client == LDLM_NAMESPACE_SERVER); 516 return ns->ns_client == LDLM_NAMESPACE_CLIENT; 517} 518 519/** 520 * Returns 1 if namespace \a ns is a server namespace. 521 */ 522static inline int ns_is_server(struct ldlm_namespace *ns) 523{ 524 LASSERT(ns != NULL); 525 LASSERT(!(ns->ns_client & ~(LDLM_NAMESPACE_CLIENT | 526 LDLM_NAMESPACE_SERVER))); 527 LASSERT(ns->ns_client == LDLM_NAMESPACE_CLIENT || 528 ns->ns_client == LDLM_NAMESPACE_SERVER); 529 return ns->ns_client == LDLM_NAMESPACE_SERVER; 530} 531 532/** 533 * Returns 1 if namespace \a ns supports early lock cancel (ELC). 534 */ 535static inline int ns_connect_cancelset(struct ldlm_namespace *ns) 536{ 537 LASSERT(ns != NULL); 538 return !!(ns->ns_connect_flags & OBD_CONNECT_CANCELSET); 539} 540 541/** 542 * Returns 1 if this namespace supports lru_resize. 543 */ 544static inline int ns_connect_lru_resize(struct ldlm_namespace *ns) 545{ 546 LASSERT(ns != NULL); 547 return !!(ns->ns_connect_flags & OBD_CONNECT_LRU_RESIZE); 548} 549 550static inline void ns_register_cancel(struct ldlm_namespace *ns, 551 ldlm_cancel_for_recovery arg) 552{ 553 LASSERT(ns != NULL); 554 ns->ns_cancel_for_recovery = arg; 555} 556 557struct ldlm_lock; 558 559/** Type for blocking callback function of a lock. */ 560typedef int (*ldlm_blocking_callback)(struct ldlm_lock *lock, 561 struct ldlm_lock_desc *new, void *data, 562 int flag); 563/** Type for completion callback function of a lock. */ 564typedef int (*ldlm_completion_callback)(struct ldlm_lock *lock, __u64 flags, 565 void *data); 566/** Type for glimpse callback function of a lock. */ 567typedef int (*ldlm_glimpse_callback)(struct ldlm_lock *lock, void *data); 568 569/** Work list for sending GL ASTs to multiple locks. */ 570struct ldlm_glimpse_work { 571 struct ldlm_lock *gl_lock; /* lock to glimpse */ 572 struct list_head gl_list; /* linkage to other gl work structs */ 573 __u32 gl_flags;/* see LDLM_GL_WORK_* below */ 574 union ldlm_gl_desc *gl_desc; /* glimpse descriptor to be packed in 575 * glimpse callback request */ 576}; 577 578/** The ldlm_glimpse_work is allocated on the stack and should not be freed. */ 579#define LDLM_GL_WORK_NOFREE 0x1 580 581/** Interval node data for each LDLM_EXTENT lock. */ 582struct ldlm_interval { 583 struct interval_node li_node; /* node for tree management */ 584 struct list_head li_group; /* the locks which have the same 585 * policy - group of the policy */ 586}; 587#define to_ldlm_interval(n) container_of(n, struct ldlm_interval, li_node) 588 589/** 590 * Interval tree for extent locks. 591 * The interval tree must be accessed under the resource lock. 592 * Interval trees are used for granted extent locks to speed up conflicts 593 * lookup. See ldlm/interval_tree.c for more details. 594 */ 595struct ldlm_interval_tree { 596 /** Tree size. */ 597 int lit_size; 598 ldlm_mode_t lit_mode; /* lock mode */ 599 struct interval_node *lit_root; /* actual ldlm_interval */ 600}; 601 602/** Whether to track references to exports by LDLM locks. */ 603#define LUSTRE_TRACKS_LOCK_EXP_REFS (0) 604 605/** Cancel flags. */ 606typedef enum { 607 LCF_ASYNC = 0x1, /* Cancel locks asynchronously. */ 608 LCF_LOCAL = 0x2, /* Cancel locks locally, not notifing server */ 609 LCF_BL_AST = 0x4, /* Cancel locks marked as LDLM_FL_BL_AST 610 * in the same RPC */ 611} ldlm_cancel_flags_t; 612 613struct ldlm_flock { 614 __u64 start; 615 __u64 end; 616 __u64 owner; 617 __u64 blocking_owner; 618 struct obd_export *blocking_export; 619 /* Protected by the hash lock */ 620 __u32 blocking_refs; 621 __u32 pid; 622}; 623 624typedef union { 625 struct ldlm_extent l_extent; 626 struct ldlm_flock l_flock; 627 struct ldlm_inodebits l_inodebits; 628} ldlm_policy_data_t; 629 630void ldlm_convert_policy_to_wire(ldlm_type_t type, 631 const ldlm_policy_data_t *lpolicy, 632 ldlm_wire_policy_data_t *wpolicy); 633void ldlm_convert_policy_to_local(struct obd_export *exp, ldlm_type_t type, 634 const ldlm_wire_policy_data_t *wpolicy, 635 ldlm_policy_data_t *lpolicy); 636 637enum lvb_type { 638 LVB_T_NONE = 0, 639 LVB_T_OST = 1, 640 LVB_T_LQUOTA = 2, 641 LVB_T_LAYOUT = 3, 642}; 643 644/** 645 * LDLM lock structure 646 * 647 * Represents a single LDLM lock and its state in memory. Each lock is 648 * associated with a single ldlm_resource, the object which is being 649 * locked. There may be multiple ldlm_locks on a single resource, 650 * depending on the lock type and whether the locks are conflicting or 651 * not. 652 */ 653struct ldlm_lock { 654 /** 655 * Local lock handle. 656 * When remote side wants to tell us about a lock, they address 657 * it by this opaque handle. The handle does not hold a 658 * reference on the ldlm_lock, so it can be safely passed to 659 * other threads or nodes. When the lock needs to be accessed 660 * from the handle, it is looked up again in the lock table, and 661 * may no longer exist. 662 * 663 * Must be first in the structure. 664 */ 665 struct portals_handle l_handle; 666 /** 667 * Lock reference count. 668 * This is how many users have pointers to actual structure, so that 669 * we do not accidentally free lock structure that is in use. 670 */ 671 atomic_t l_refc; 672 /** 673 * Internal spinlock protects l_resource. We should hold this lock 674 * first before taking res_lock. 675 */ 676 spinlock_t l_lock; 677 /** 678 * Pointer to actual resource this lock is in. 679 * ldlm_lock_change_resource() can change this. 680 */ 681 struct ldlm_resource *l_resource; 682 /** 683 * List item for client side LRU list. 684 * Protected by ns_lock in struct ldlm_namespace. 685 */ 686 struct list_head l_lru; 687 /** 688 * Linkage to resource's lock queues according to current lock state. 689 * (could be granted, waiting or converting) 690 * Protected by lr_lock in struct ldlm_resource. 691 */ 692 struct list_head l_res_link; 693 /** 694 * Tree node for ldlm_extent. 695 */ 696 struct ldlm_interval *l_tree_node; 697 /** 698 * Per export hash of locks. 699 * Protected by per-bucket exp->exp_lock_hash locks. 700 */ 701 struct hlist_node l_exp_hash; 702 /** 703 * Per export hash of flock locks. 704 * Protected by per-bucket exp->exp_flock_hash locks. 705 */ 706 struct hlist_node l_exp_flock_hash; 707 /** 708 * Requested mode. 709 * Protected by lr_lock. 710 */ 711 ldlm_mode_t l_req_mode; 712 /** 713 * Granted mode, also protected by lr_lock. 714 */ 715 ldlm_mode_t l_granted_mode; 716 /** Lock completion handler pointer. Called when lock is granted. */ 717 ldlm_completion_callback l_completion_ast; 718 /** 719 * Lock blocking AST handler pointer. 720 * It plays two roles: 721 * - as a notification of an attempt to queue a conflicting lock (once) 722 * - as a notification when the lock is being cancelled. 723 * 724 * As such it's typically called twice: once for the initial conflict 725 * and then once more when the last user went away and the lock is 726 * cancelled (could happen recursively). 727 */ 728 ldlm_blocking_callback l_blocking_ast; 729 /** 730 * Lock glimpse handler. 731 * Glimpse handler is used to obtain LVB updates from a client by 732 * server 733 */ 734 ldlm_glimpse_callback l_glimpse_ast; 735 736 /** 737 * Lock export. 738 * This is a pointer to actual client export for locks that were granted 739 * to clients. Used server-side. 740 */ 741 struct obd_export *l_export; 742 /** 743 * Lock connection export. 744 * Pointer to server export on a client. 745 */ 746 struct obd_export *l_conn_export; 747 748 /** 749 * Remote lock handle. 750 * If the lock is remote, this is the handle of the other side lock 751 * (l_handle) 752 */ 753 struct lustre_handle l_remote_handle; 754 755 /** 756 * Representation of private data specific for a lock type. 757 * Examples are: extent range for extent lock or bitmask for ibits locks 758 */ 759 ldlm_policy_data_t l_policy_data; 760 761 /** 762 * Lock state flags. Protected by lr_lock. 763 * \see lustre_dlm_flags.h where the bits are defined. 764 */ 765 __u64 l_flags; 766 767 /** 768 * Lock r/w usage counters. 769 * Protected by lr_lock. 770 */ 771 __u32 l_readers; 772 __u32 l_writers; 773 /** 774 * If the lock is granted, a process sleeps on this waitq to learn when 775 * it's no longer in use. If the lock is not granted, a process sleeps 776 * on this waitq to learn when it becomes granted. 777 */ 778 wait_queue_head_t l_waitq; 779 780 /** 781 * Seconds. It will be updated if there is any activity related to 782 * the lock, e.g. enqueue the lock or send blocking AST. 783 */ 784 unsigned long l_last_activity; 785 786 /** 787 * Time last used by e.g. being matched by lock match. 788 * Jiffies. Should be converted to time if needed. 789 */ 790 unsigned long l_last_used; 791 792 /** Originally requested extent for the extent lock. */ 793 struct ldlm_extent l_req_extent; 794 795 /* 796 * Client-side-only members. 797 */ 798 799 enum lvb_type l_lvb_type; 800 801 /** 802 * Temporary storage for a LVB received during an enqueue operation. 803 */ 804 __u32 l_lvb_len; 805 void *l_lvb_data; 806 807 /** Private storage for lock user. Opaque to LDLM. */ 808 void *l_ast_data; 809 810 /* 811 * Server-side-only members. 812 */ 813 814 /** 815 * Connection cookie for the client originating the operation. 816 * Used by Commit on Share (COS) code. Currently only used for 817 * inodebits locks on MDS. 818 */ 819 __u64 l_client_cookie; 820 821 /** 822 * List item for locks waiting for cancellation from clients. 823 * The lists this could be linked into are: 824 * waiting_locks_list (protected by waiting_locks_spinlock), 825 * then if the lock timed out, it is moved to 826 * expired_lock_thread.elt_expired_locks for further processing. 827 * Protected by elt_lock. 828 */ 829 struct list_head l_pending_chain; 830 831 /** 832 * Set when lock is sent a blocking AST. Time in seconds when timeout 833 * is reached and client holding this lock could be evicted. 834 * This timeout could be further extended by e.g. certain IO activity 835 * under this lock. 836 * \see ost_rw_prolong_locks 837 */ 838 unsigned long l_callback_timeout; 839 840 /** Local PID of process which created this lock. */ 841 __u32 l_pid; 842 843 /** 844 * Number of times blocking AST was sent for this lock. 845 * This is for debugging. Valid values are 0 and 1, if there is an 846 * attempt to send blocking AST more than once, an assertion would be 847 * hit. \see ldlm_work_bl_ast_lock 848 */ 849 int l_bl_ast_run; 850 /** List item ldlm_add_ast_work_item() for case of blocking ASTs. */ 851 struct list_head l_bl_ast; 852 /** List item ldlm_add_ast_work_item() for case of completion ASTs. */ 853 struct list_head l_cp_ast; 854 /** For ldlm_add_ast_work_item() for "revoke" AST used in COS. */ 855 struct list_head l_rk_ast; 856 857 /** 858 * Pointer to a conflicting lock that caused blocking AST to be sent 859 * for this lock 860 */ 861 struct ldlm_lock *l_blocking_lock; 862 863 /** 864 * Protected by lr_lock, linkages to "skip lists". 865 * For more explanations of skip lists see ldlm/ldlm_inodebits.c 866 */ 867 struct list_head l_sl_mode; 868 struct list_head l_sl_policy; 869 870 /** Reference tracking structure to debug leaked locks. */ 871 struct lu_ref l_reference; 872#if LUSTRE_TRACKS_LOCK_EXP_REFS 873 /* Debugging stuff for bug 20498, for tracking export references. */ 874 /** number of export references taken */ 875 int l_exp_refs_nr; 876 /** link all locks referencing one export */ 877 struct list_head l_exp_refs_link; 878 /** referenced export object */ 879 struct obd_export *l_exp_refs_target; 880#endif 881 /** 882 * export blocking dlm lock list, protected by 883 * l_export->exp_bl_list_lock. 884 * Lock order of waiting_lists_spinlock, exp_bl_list_lock and res lock 885 * is: res lock -> exp_bl_list_lock -> wanting_lists_spinlock. 886 */ 887 struct list_head l_exp_list; 888}; 889 890/** 891 * LDLM resource description. 892 * Basically, resource is a representation for a single object. 893 * Object has a name which is currently 4 64-bit integers. LDLM user is 894 * responsible for creation of a mapping between objects it wants to be 895 * protected and resource names. 896 * 897 * A resource can only hold locks of a single lock type, though there may be 898 * multiple ldlm_locks on a single resource, depending on the lock type and 899 * whether the locks are conflicting or not. 900 */ 901struct ldlm_resource { 902 struct ldlm_ns_bucket *lr_ns_bucket; 903 904 /** 905 * List item for list in namespace hash. 906 * protected by ns_lock 907 */ 908 struct hlist_node lr_hash; 909 910 /** Spinlock to protect locks under this resource. */ 911 spinlock_t lr_lock; 912 913 /** 914 * protected by lr_lock 915 * @{ */ 916 /** List of locks in granted state */ 917 struct list_head lr_granted; 918 /** List of locks waiting to change their granted mode (converted) */ 919 struct list_head lr_converting; 920 /** 921 * List of locks that could not be granted due to conflicts and 922 * that are waiting for conflicts to go away */ 923 struct list_head lr_waiting; 924 /** @} */ 925 926 /* XXX No longer needed? Remove ASAP */ 927 ldlm_mode_t lr_most_restr; 928 929 /** Type of locks this resource can hold. Only one type per resource. */ 930 ldlm_type_t lr_type; /* LDLM_{PLAIN,EXTENT,FLOCK,IBITS} */ 931 932 /** Resource name */ 933 struct ldlm_res_id lr_name; 934 /** Reference count for this resource */ 935 atomic_t lr_refcount; 936 937 /** 938 * Interval trees (only for extent locks) for all modes of this resource 939 */ 940 struct ldlm_interval_tree lr_itree[LCK_MODE_NUM]; 941 942 /** 943 * Server-side-only lock value block elements. 944 * To serialize lvbo_init. 945 */ 946 struct mutex lr_lvb_mutex; 947 int lr_lvb_len; 948 /** protected by lr_lock */ 949 void *lr_lvb_data; 950 951 /** When the resource was considered as contended. */ 952 unsigned long lr_contention_time; 953 /** List of references to this resource. For debugging. */ 954 struct lu_ref lr_reference; 955 956 struct inode *lr_lvb_inode; 957}; 958 959static inline bool ldlm_has_layout(struct ldlm_lock *lock) 960{ 961 return lock->l_resource->lr_type == LDLM_IBITS && 962 lock->l_policy_data.l_inodebits.bits & MDS_INODELOCK_LAYOUT; 963} 964 965static inline char * 966ldlm_ns_name(struct ldlm_namespace *ns) 967{ 968 return ns->ns_rs_hash->hs_name; 969} 970 971static inline struct ldlm_namespace * 972ldlm_res_to_ns(struct ldlm_resource *res) 973{ 974 return res->lr_ns_bucket->nsb_namespace; 975} 976 977static inline struct ldlm_namespace * 978ldlm_lock_to_ns(struct ldlm_lock *lock) 979{ 980 return ldlm_res_to_ns(lock->l_resource); 981} 982 983static inline char * 984ldlm_lock_to_ns_name(struct ldlm_lock *lock) 985{ 986 return ldlm_ns_name(ldlm_lock_to_ns(lock)); 987} 988 989static inline struct adaptive_timeout * 990ldlm_lock_to_ns_at(struct ldlm_lock *lock) 991{ 992 return &lock->l_resource->lr_ns_bucket->nsb_at_estimate; 993} 994 995static inline int ldlm_lvbo_init(struct ldlm_resource *res) 996{ 997 struct ldlm_namespace *ns = ldlm_res_to_ns(res); 998 999 if (ns->ns_lvbo != NULL && ns->ns_lvbo->lvbo_init != NULL) 1000 return ns->ns_lvbo->lvbo_init(res); 1001 1002 return 0; 1003} 1004 1005static inline int ldlm_lvbo_size(struct ldlm_lock *lock) 1006{ 1007 struct ldlm_namespace *ns = ldlm_lock_to_ns(lock); 1008 1009 if (ns->ns_lvbo != NULL && ns->ns_lvbo->lvbo_size != NULL) 1010 return ns->ns_lvbo->lvbo_size(lock); 1011 1012 return 0; 1013} 1014 1015static inline int ldlm_lvbo_fill(struct ldlm_lock *lock, void *buf, int len) 1016{ 1017 struct ldlm_namespace *ns = ldlm_lock_to_ns(lock); 1018 1019 if (ns->ns_lvbo != NULL) { 1020 LASSERT(ns->ns_lvbo->lvbo_fill != NULL); 1021 return ns->ns_lvbo->lvbo_fill(lock, buf, len); 1022 } 1023 return 0; 1024} 1025 1026struct ldlm_ast_work { 1027 struct ldlm_lock *w_lock; 1028 int w_blocking; 1029 struct ldlm_lock_desc w_desc; 1030 struct list_head w_list; 1031 int w_flags; 1032 void *w_data; 1033 int w_datalen; 1034}; 1035 1036/** 1037 * Common ldlm_enqueue parameters 1038 */ 1039struct ldlm_enqueue_info { 1040 __u32 ei_type; /** Type of the lock being enqueued. */ 1041 __u32 ei_mode; /** Mode of the lock being enqueued. */ 1042 void *ei_cb_bl; /** blocking lock callback */ 1043 void *ei_cb_cp; /** lock completion callback */ 1044 void *ei_cb_gl; /** lock glimpse callback */ 1045 void *ei_cbdata; /** Data to be passed into callbacks. */ 1046}; 1047 1048extern struct obd_ops ldlm_obd_ops; 1049 1050extern char *ldlm_lockname[]; 1051extern char *ldlm_typename[]; 1052extern char *ldlm_it2str(int it); 1053 1054/** 1055 * Just a fancy CDEBUG call with log level preset to LDLM_DEBUG. 1056 * For the cases where we do not have actual lock to print along 1057 * with a debugging message that is ldlm-related 1058 */ 1059#define LDLM_DEBUG_NOLOCK(format, a...) \ 1060 CDEBUG(D_DLMTRACE, "### " format "\n" , ##a) 1061 1062/** 1063 * Support function for lock information printing into debug logs. 1064 * \see LDLM_DEBUG 1065 */ 1066#define ldlm_lock_debug(msgdata, mask, cdls, lock, fmt, a...) do { \ 1067 CFS_CHECK_STACK(msgdata, mask, cdls); \ 1068 \ 1069 if (((mask) & D_CANTMASK) != 0 || \ 1070 ((libcfs_debug & (mask)) != 0 && \ 1071 (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) \ 1072 _ldlm_lock_debug(lock, msgdata, fmt, ##a); \ 1073} while (0) 1074 1075void _ldlm_lock_debug(struct ldlm_lock *lock, 1076 struct libcfs_debug_msg_data *data, 1077 const char *fmt, ...) 1078 __attribute__ ((format (printf, 3, 4))); 1079 1080/** 1081 * Rate-limited version of lock printing function. 1082 */ 1083#define LDLM_DEBUG_LIMIT(mask, lock, fmt, a...) do { \ 1084 static struct cfs_debug_limit_state _ldlm_cdls; \ 1085 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, &_ldlm_cdls); \ 1086 ldlm_lock_debug(&msgdata, mask, &_ldlm_cdls, lock, "### " fmt , ##a);\ 1087} while (0) 1088 1089#define LDLM_ERROR(lock, fmt, a...) LDLM_DEBUG_LIMIT(D_ERROR, lock, fmt, ## a) 1090#define LDLM_WARN(lock, fmt, a...) LDLM_DEBUG_LIMIT(D_WARNING, lock, fmt, ## a) 1091 1092/** Non-rate-limited lock printing function for debugging purposes. */ 1093#define LDLM_DEBUG(lock, fmt, a...) do { \ 1094 if (likely(lock != NULL)) { \ 1095 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_DLMTRACE, NULL); \ 1096 ldlm_lock_debug(&msgdata, D_DLMTRACE, NULL, lock, \ 1097 "### " fmt , ##a); \ 1098 } else { \ 1099 LDLM_DEBUG_NOLOCK("no dlm lock: " fmt, ##a); \ 1100 } \ 1101} while (0) 1102 1103typedef int (*ldlm_processing_policy)(struct ldlm_lock *lock, __u64 *flags, 1104 int first_enq, ldlm_error_t *err, 1105 struct list_head *work_list); 1106 1107/** 1108 * Return values for lock iterators. 1109 * Also used during deciding of lock grants and cancellations. 1110 */ 1111#define LDLM_ITER_CONTINUE 1 /* keep iterating */ 1112#define LDLM_ITER_STOP 2 /* stop iterating */ 1113 1114typedef int (*ldlm_iterator_t)(struct ldlm_lock *, void *); 1115typedef int (*ldlm_res_iterator_t)(struct ldlm_resource *, void *); 1116 1117/** \defgroup ldlm_iterator Lock iterators 1118 * 1119 * LDLM provides for a way to iterate through every lock on a resource or 1120 * namespace or every resource in a namespace. 1121 * @{ */ 1122int ldlm_resource_foreach(struct ldlm_resource *res, ldlm_iterator_t iter, 1123 void *closure); 1124void ldlm_namespace_foreach(struct ldlm_namespace *ns, ldlm_iterator_t iter, 1125 void *closure); 1126int ldlm_resource_iterate(struct ldlm_namespace *, const struct ldlm_res_id *, 1127 ldlm_iterator_t iter, void *data); 1128/** @} ldlm_iterator */ 1129 1130int ldlm_replay_locks(struct obd_import *imp); 1131 1132/* ldlm_flock.c */ 1133int ldlm_flock_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data); 1134 1135/* ldlm_extent.c */ 1136__u64 ldlm_extent_shift_kms(struct ldlm_lock *lock, __u64 old_kms); 1137 1138struct ldlm_callback_suite { 1139 ldlm_completion_callback lcs_completion; 1140 ldlm_blocking_callback lcs_blocking; 1141 ldlm_glimpse_callback lcs_glimpse; 1142}; 1143 1144/* ldlm_lockd.c */ 1145int ldlm_del_waiting_lock(struct ldlm_lock *lock); 1146int ldlm_refresh_waiting_lock(struct ldlm_lock *lock, int timeout); 1147int ldlm_get_ref(void); 1148void ldlm_put_ref(void); 1149int ldlm_init_export(struct obd_export *exp); 1150void ldlm_destroy_export(struct obd_export *exp); 1151struct ldlm_lock *ldlm_request_lock(struct ptlrpc_request *req); 1152 1153/* ldlm_lock.c */ 1154void ldlm_register_intent(struct ldlm_namespace *ns, ldlm_res_policy arg); 1155void ldlm_lock2handle(const struct ldlm_lock *lock, 1156 struct lustre_handle *lockh); 1157struct ldlm_lock *__ldlm_handle2lock(const struct lustre_handle *, __u64 flags); 1158void ldlm_cancel_callback(struct ldlm_lock *); 1159int ldlm_lock_remove_from_lru(struct ldlm_lock *); 1160int ldlm_lock_set_data(struct lustre_handle *, void *); 1161 1162/** 1163 * Obtain a lock reference by its handle. 1164 */ 1165static inline struct ldlm_lock *ldlm_handle2lock(const struct lustre_handle *h) 1166{ 1167 return __ldlm_handle2lock(h, 0); 1168} 1169 1170#define LDLM_LOCK_REF_DEL(lock) \ 1171 lu_ref_del(&lock->l_reference, "handle", current) 1172 1173static inline struct ldlm_lock * 1174ldlm_handle2lock_long(const struct lustre_handle *h, __u64 flags) 1175{ 1176 struct ldlm_lock *lock; 1177 1178 lock = __ldlm_handle2lock(h, flags); 1179 if (lock != NULL) 1180 LDLM_LOCK_REF_DEL(lock); 1181 return lock; 1182} 1183 1184/** 1185 * Update Lock Value Block Operations (LVBO) on a resource taking into account 1186 * data from request \a r 1187 */ 1188static inline int ldlm_res_lvbo_update(struct ldlm_resource *res, 1189 struct ptlrpc_request *r, int increase) 1190{ 1191 if (ldlm_res_to_ns(res)->ns_lvbo && 1192 ldlm_res_to_ns(res)->ns_lvbo->lvbo_update) { 1193 return ldlm_res_to_ns(res)->ns_lvbo->lvbo_update(res, r, 1194 increase); 1195 } 1196 return 0; 1197} 1198 1199int ldlm_error2errno(ldlm_error_t error); 1200ldlm_error_t ldlm_errno2error(int err_no); /* don't call it `errno': this 1201 * confuses user-space. */ 1202#if LUSTRE_TRACKS_LOCK_EXP_REFS 1203void ldlm_dump_export_locks(struct obd_export *exp); 1204#endif 1205 1206/** 1207 * Release a temporary lock reference obtained by ldlm_handle2lock() or 1208 * __ldlm_handle2lock(). 1209 */ 1210#define LDLM_LOCK_PUT(lock) \ 1211do { \ 1212 LDLM_LOCK_REF_DEL(lock); \ 1213 /*LDLM_DEBUG((lock), "put");*/ \ 1214 ldlm_lock_put(lock); \ 1215} while (0) 1216 1217/** 1218 * Release a lock reference obtained by some other means (see 1219 * LDLM_LOCK_PUT()). 1220 */ 1221#define LDLM_LOCK_RELEASE(lock) \ 1222do { \ 1223 /*LDLM_DEBUG((lock), "put");*/ \ 1224 ldlm_lock_put(lock); \ 1225} while (0) 1226 1227#define LDLM_LOCK_GET(lock) \ 1228({ \ 1229 ldlm_lock_get(lock); \ 1230 /*LDLM_DEBUG((lock), "get");*/ \ 1231 lock; \ 1232}) 1233 1234#define ldlm_lock_list_put(head, member, count) \ 1235({ \ 1236 struct ldlm_lock *_lock, *_next; \ 1237 int c = count; \ 1238 list_for_each_entry_safe(_lock, _next, head, member) { \ 1239 if (c-- == 0) \ 1240 break; \ 1241 list_del_init(&_lock->member); \ 1242 LDLM_LOCK_RELEASE(_lock); \ 1243 } \ 1244 LASSERT(c <= 0); \ 1245}) 1246 1247struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock); 1248void ldlm_lock_put(struct ldlm_lock *lock); 1249void ldlm_lock_destroy(struct ldlm_lock *lock); 1250void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc); 1251void ldlm_lock_addref(struct lustre_handle *lockh, __u32 mode); 1252int ldlm_lock_addref_try(struct lustre_handle *lockh, __u32 mode); 1253void ldlm_lock_decref(struct lustre_handle *lockh, __u32 mode); 1254void ldlm_lock_decref_and_cancel(struct lustre_handle *lockh, __u32 mode); 1255void ldlm_lock_fail_match_locked(struct ldlm_lock *lock); 1256void ldlm_lock_fail_match(struct ldlm_lock *lock); 1257void ldlm_lock_allow_match(struct ldlm_lock *lock); 1258void ldlm_lock_allow_match_locked(struct ldlm_lock *lock); 1259ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, __u64 flags, 1260 const struct ldlm_res_id *, ldlm_type_t type, 1261 ldlm_policy_data_t *, ldlm_mode_t mode, 1262 struct lustre_handle *, int unref); 1263ldlm_mode_t ldlm_revalidate_lock_handle(struct lustre_handle *lockh, 1264 __u64 *bits); 1265struct ldlm_resource *ldlm_lock_convert(struct ldlm_lock *lock, int new_mode, 1266 __u32 *flags); 1267void ldlm_lock_downgrade(struct ldlm_lock *lock, int new_mode); 1268void ldlm_lock_cancel(struct ldlm_lock *lock); 1269void ldlm_reprocess_all(struct ldlm_resource *res); 1270void ldlm_reprocess_all_ns(struct ldlm_namespace *ns); 1271void ldlm_lock_dump_handle(int level, struct lustre_handle *); 1272void ldlm_unlink_lock_skiplist(struct ldlm_lock *req); 1273 1274/* resource.c */ 1275struct ldlm_namespace * 1276ldlm_namespace_new(struct obd_device *obd, char *name, 1277 ldlm_side_t client, ldlm_appetite_t apt, 1278 ldlm_ns_type_t ns_type); 1279int ldlm_namespace_cleanup(struct ldlm_namespace *ns, __u64 flags); 1280void ldlm_namespace_free(struct ldlm_namespace *ns, 1281 struct obd_import *imp, int force); 1282void ldlm_namespace_register(struct ldlm_namespace *ns, ldlm_side_t client); 1283void ldlm_namespace_unregister(struct ldlm_namespace *ns, ldlm_side_t client); 1284void ldlm_namespace_get(struct ldlm_namespace *ns); 1285void ldlm_namespace_put(struct ldlm_namespace *ns); 1286#if defined (CONFIG_PROC_FS) 1287int ldlm_proc_setup(void); 1288void ldlm_proc_cleanup(void); 1289#else 1290static inline int ldlm_proc_setup(void) { return 0; } 1291static inline void ldlm_proc_cleanup(void) {} 1292#endif 1293 1294/* resource.c - internal */ 1295struct ldlm_resource *ldlm_resource_get(struct ldlm_namespace *ns, 1296 struct ldlm_resource *parent, 1297 const struct ldlm_res_id *, 1298 ldlm_type_t type, int create); 1299struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res); 1300int ldlm_resource_putref(struct ldlm_resource *res); 1301void ldlm_resource_add_lock(struct ldlm_resource *res, 1302 struct list_head *head, 1303 struct ldlm_lock *lock); 1304void ldlm_resource_unlink_lock(struct ldlm_lock *lock); 1305void ldlm_res2desc(struct ldlm_resource *res, struct ldlm_resource_desc *desc); 1306void ldlm_dump_all_namespaces(ldlm_side_t client, int level); 1307void ldlm_namespace_dump(int level, struct ldlm_namespace *); 1308void ldlm_resource_dump(int level, struct ldlm_resource *); 1309int ldlm_lock_change_resource(struct ldlm_namespace *, struct ldlm_lock *, 1310 const struct ldlm_res_id *); 1311 1312#define LDLM_RESOURCE_ADDREF(res) do { \ 1313 lu_ref_add_atomic(&(res)->lr_reference, __func__, current); \ 1314} while (0) 1315 1316#define LDLM_RESOURCE_DELREF(res) do { \ 1317 lu_ref_del(&(res)->lr_reference, __func__, current); \ 1318} while (0) 1319 1320/* ldlm_request.c */ 1321int ldlm_expired_completion_wait(void *data); 1322/** \defgroup ldlm_local_ast Default AST handlers for local locks 1323 * These AST handlers are typically used for server-side local locks and are 1324 * also used by client-side lock handlers to perform minimum level base 1325 * processing. 1326 * @{ */ 1327int ldlm_blocking_ast_nocheck(struct ldlm_lock *lock); 1328int ldlm_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, 1329 void *data, int flag); 1330int ldlm_glimpse_ast(struct ldlm_lock *lock, void *reqp); 1331int ldlm_completion_ast_async(struct ldlm_lock *lock, __u64 flags, void *data); 1332int ldlm_completion_ast(struct ldlm_lock *lock, __u64 flags, void *data); 1333/** @} ldlm_local_ast */ 1334 1335/** \defgroup ldlm_cli_api API to operate on locks from actual LDLM users. 1336 * These are typically used by client and server (*_local versions) 1337 * to obtain and release locks. 1338 * @{ */ 1339int ldlm_cli_enqueue(struct obd_export *exp, struct ptlrpc_request **reqp, 1340 struct ldlm_enqueue_info *einfo, 1341 const struct ldlm_res_id *res_id, 1342 ldlm_policy_data_t const *policy, __u64 *flags, 1343 void *lvb, __u32 lvb_len, enum lvb_type lvb_type, 1344 struct lustre_handle *lockh, int async); 1345int ldlm_prep_enqueue_req(struct obd_export *exp, 1346 struct ptlrpc_request *req, 1347 struct list_head *cancels, 1348 int count); 1349int ldlm_prep_elc_req(struct obd_export *exp, 1350 struct ptlrpc_request *req, 1351 int version, int opc, int canceloff, 1352 struct list_head *cancels, int count); 1353 1354struct ptlrpc_request *ldlm_enqueue_pack(struct obd_export *exp, int lvb_len); 1355int ldlm_handle_enqueue0(struct ldlm_namespace *ns, struct ptlrpc_request *req, 1356 const struct ldlm_request *dlm_req, 1357 const struct ldlm_callback_suite *cbs); 1358int ldlm_cli_enqueue_fini(struct obd_export *exp, struct ptlrpc_request *req, 1359 ldlm_type_t type, __u8 with_policy, ldlm_mode_t mode, 1360 __u64 *flags, void *lvb, __u32 lvb_len, 1361 struct lustre_handle *lockh, int rc); 1362int ldlm_cli_enqueue_local(struct ldlm_namespace *ns, 1363 const struct ldlm_res_id *res_id, 1364 ldlm_type_t type, ldlm_policy_data_t *policy, 1365 ldlm_mode_t mode, __u64 *flags, 1366 ldlm_blocking_callback blocking, 1367 ldlm_completion_callback completion, 1368 ldlm_glimpse_callback glimpse, 1369 void *data, __u32 lvb_len, enum lvb_type lvb_type, 1370 const __u64 *client_cookie, 1371 struct lustre_handle *lockh); 1372int ldlm_server_ast(struct lustre_handle *lockh, struct ldlm_lock_desc *new, 1373 void *data, __u32 data_len); 1374int ldlm_cli_convert(struct lustre_handle *, int new_mode, __u32 *flags); 1375int ldlm_cli_update_pool(struct ptlrpc_request *req); 1376int ldlm_cli_cancel(struct lustre_handle *lockh, 1377 ldlm_cancel_flags_t cancel_flags); 1378int ldlm_cli_cancel_unused(struct ldlm_namespace *, const struct ldlm_res_id *, 1379 ldlm_cancel_flags_t flags, void *opaque); 1380int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns, 1381 const struct ldlm_res_id *res_id, 1382 ldlm_policy_data_t *policy, 1383 ldlm_mode_t mode, 1384 ldlm_cancel_flags_t flags, 1385 void *opaque); 1386int ldlm_cli_cancel_req(struct obd_export *exp, struct list_head *head, 1387 int count, ldlm_cancel_flags_t flags); 1388int ldlm_cancel_resource_local(struct ldlm_resource *res, 1389 struct list_head *cancels, 1390 ldlm_policy_data_t *policy, 1391 ldlm_mode_t mode, __u64 lock_flags, 1392 ldlm_cancel_flags_t cancel_flags, void *opaque); 1393int ldlm_cli_cancel_list_local(struct list_head *cancels, int count, 1394 ldlm_cancel_flags_t flags); 1395int ldlm_cli_cancel_list(struct list_head *head, int count, 1396 struct ptlrpc_request *req, ldlm_cancel_flags_t flags); 1397/** @} ldlm_cli_api */ 1398 1399/* mds/handler.c */ 1400/* This has to be here because recursive inclusion sucks. */ 1401int intent_disposition(struct ldlm_reply *rep, int flag); 1402void intent_set_disposition(struct ldlm_reply *rep, int flag); 1403 1404 1405/* ioctls for trying requests */ 1406#define IOC_LDLM_TYPE 'f' 1407#define IOC_LDLM_MIN_NR 40 1408 1409#define IOC_LDLM_TEST _IOWR('f', 40, long) 1410#define IOC_LDLM_DUMP _IOWR('f', 41, long) 1411#define IOC_LDLM_REGRESS_START _IOWR('f', 42, long) 1412#define IOC_LDLM_REGRESS_STOP _IOWR('f', 43, long) 1413#define IOC_LDLM_MAX_NR 43 1414 1415/** 1416 * "Modes" of acquiring lock_res, necessary to tell lockdep that taking more 1417 * than one lock_res is dead-lock safe. 1418 */ 1419enum lock_res_type { 1420 LRT_NORMAL, 1421 LRT_NEW 1422}; 1423 1424/** Lock resource. */ 1425static inline void lock_res(struct ldlm_resource *res) 1426{ 1427 spin_lock(&res->lr_lock); 1428} 1429 1430/** Lock resource with a way to instruct lockdep code about nestedness-safe. */ 1431static inline void lock_res_nested(struct ldlm_resource *res, 1432 enum lock_res_type mode) 1433{ 1434 spin_lock_nested(&res->lr_lock, mode); 1435} 1436 1437/** Unlock resource. */ 1438static inline void unlock_res(struct ldlm_resource *res) 1439{ 1440 spin_unlock(&res->lr_lock); 1441} 1442 1443/** Check if resource is already locked, assert if not. */ 1444static inline void check_res_locked(struct ldlm_resource *res) 1445{ 1446 assert_spin_locked(&res->lr_lock); 1447} 1448 1449struct ldlm_resource * lock_res_and_lock(struct ldlm_lock *lock); 1450void unlock_res_and_lock(struct ldlm_lock *lock); 1451 1452/* ldlm_pool.c */ 1453/** \defgroup ldlm_pools Various LDLM pool related functions 1454 * There are not used outside of ldlm. 1455 * @{ 1456 */ 1457int ldlm_pools_recalc(ldlm_side_t client); 1458int ldlm_pools_init(void); 1459void ldlm_pools_fini(void); 1460 1461int ldlm_pool_init(struct ldlm_pool *pl, struct ldlm_namespace *ns, 1462 int idx, ldlm_side_t client); 1463int ldlm_pool_shrink(struct ldlm_pool *pl, int nr, 1464 gfp_t gfp_mask); 1465void ldlm_pool_fini(struct ldlm_pool *pl); 1466int ldlm_pool_setup(struct ldlm_pool *pl, int limit); 1467int ldlm_pool_recalc(struct ldlm_pool *pl); 1468__u32 ldlm_pool_get_lvf(struct ldlm_pool *pl); 1469__u64 ldlm_pool_get_slv(struct ldlm_pool *pl); 1470__u64 ldlm_pool_get_clv(struct ldlm_pool *pl); 1471__u32 ldlm_pool_get_limit(struct ldlm_pool *pl); 1472void ldlm_pool_set_slv(struct ldlm_pool *pl, __u64 slv); 1473void ldlm_pool_set_clv(struct ldlm_pool *pl, __u64 clv); 1474void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit); 1475void ldlm_pool_add(struct ldlm_pool *pl, struct ldlm_lock *lock); 1476void ldlm_pool_del(struct ldlm_pool *pl, struct ldlm_lock *lock); 1477/** @} */ 1478 1479#endif 1480/** @} LDLM */ 1481