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) 2011, 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 * lustre/include/lustre_lib.h 37 * 38 * Basic Lustre library routines. 39 */ 40 41#ifndef _LUSTRE_LIB_H 42#define _LUSTRE_LIB_H 43 44/** \defgroup lib lib 45 * 46 * @{ 47 */ 48 49#include <linux/sched.h> 50#include <linux/signal.h> 51#include <linux/types.h> 52#include "../../include/linux/libcfs/libcfs.h" 53#include "lustre/lustre_idl.h" 54#include "lustre_ver.h" 55#include "lustre_cfg.h" 56 57/* target.c */ 58struct kstatfs; 59struct ptlrpc_request; 60struct obd_export; 61struct lu_target; 62struct l_wait_info; 63#include "lustre_ha.h" 64#include "lustre_net.h" 65 66#define LI_POISON 0x5a5a5a5a 67#if BITS_PER_LONG > 32 68# define LL_POISON 0x5a5a5a5a5a5a5a5aL 69#else 70# define LL_POISON 0x5a5a5a5aL 71#endif 72#define LP_POISON ((void *)LL_POISON) 73 74int target_pack_pool_reply(struct ptlrpc_request *req); 75int do_set_info_async(struct obd_import *imp, 76 int opcode, int version, 77 u32 keylen, void *key, 78 u32 vallen, void *val, 79 struct ptlrpc_request_set *set); 80 81#define OBD_RECOVERY_MAX_TIME (obd_timeout * 18) /* b13079 */ 82#define OBD_MAX_IOCTL_BUFFER CONFIG_LUSTRE_OBD_MAX_IOCTL_BUFFER 83 84void target_send_reply(struct ptlrpc_request *req, int rc, int fail_id); 85 86/* client.c */ 87 88int client_sanobd_setup(struct obd_device *obddev, struct lustre_cfg* lcfg); 89struct client_obd *client_conn2cli(struct lustre_handle *conn); 90 91struct md_open_data; 92struct obd_client_handle { 93 struct lustre_handle och_fh; 94 struct lu_fid och_fid; 95 struct md_open_data *och_mod; 96 struct lustre_handle och_lease_handle; /* open lock for lease */ 97 __u32 och_magic; 98 fmode_t och_flags; 99}; 100#define OBD_CLIENT_HANDLE_MAGIC 0xd15ea5ed 101 102/* statfs_pack.c */ 103void statfs_pack(struct obd_statfs *osfs, struct kstatfs *sfs); 104void statfs_unpack(struct kstatfs *sfs, struct obd_statfs *osfs); 105 106/* 107 * For md echo client 108 */ 109enum md_echo_cmd { 110 ECHO_MD_CREATE = 1, /* Open/Create file on MDT */ 111 ECHO_MD_MKDIR = 2, /* Mkdir on MDT */ 112 ECHO_MD_DESTROY = 3, /* Unlink file on MDT */ 113 ECHO_MD_RMDIR = 4, /* Rmdir on MDT */ 114 ECHO_MD_LOOKUP = 5, /* Lookup on MDT */ 115 ECHO_MD_GETATTR = 6, /* Getattr on MDT */ 116 ECHO_MD_SETATTR = 7, /* Setattr on MDT */ 117 ECHO_MD_ALLOC_FID = 8, /* Get FIDs from MDT */ 118}; 119 120/* 121 * OBD IOCTLS 122 */ 123#define OBD_IOCTL_VERSION 0x00010004 124 125struct obd_ioctl_data { 126 __u32 ioc_len; 127 __u32 ioc_version; 128 129 union { 130 __u64 ioc_cookie; 131 __u64 ioc_u64_1; 132 }; 133 union { 134 __u32 ioc_conn1; 135 __u32 ioc_u32_1; 136 }; 137 union { 138 __u32 ioc_conn2; 139 __u32 ioc_u32_2; 140 }; 141 142 struct obdo ioc_obdo1; 143 struct obdo ioc_obdo2; 144 145 u64 ioc_count; 146 u64 ioc_offset; 147 __u32 ioc_dev; 148 __u32 ioc_command; 149 150 __u64 ioc_nid; 151 __u32 ioc_nal; 152 __u32 ioc_type; 153 154 /* buffers the kernel will treat as user pointers */ 155 __u32 ioc_plen1; 156 char *ioc_pbuf1; 157 __u32 ioc_plen2; 158 char *ioc_pbuf2; 159 160 /* inline buffers for various arguments */ 161 __u32 ioc_inllen1; 162 char *ioc_inlbuf1; 163 __u32 ioc_inllen2; 164 char *ioc_inlbuf2; 165 __u32 ioc_inllen3; 166 char *ioc_inlbuf3; 167 __u32 ioc_inllen4; 168 char *ioc_inlbuf4; 169 170 char ioc_bulk[0]; 171}; 172 173struct obd_ioctl_hdr { 174 __u32 ioc_len; 175 __u32 ioc_version; 176}; 177 178static inline int obd_ioctl_packlen(struct obd_ioctl_data *data) 179{ 180 int len = cfs_size_round(sizeof(struct obd_ioctl_data)); 181 len += cfs_size_round(data->ioc_inllen1); 182 len += cfs_size_round(data->ioc_inllen2); 183 len += cfs_size_round(data->ioc_inllen3); 184 len += cfs_size_round(data->ioc_inllen4); 185 return len; 186} 187 188 189static inline int obd_ioctl_is_invalid(struct obd_ioctl_data *data) 190{ 191 if (data->ioc_len > OBD_MAX_IOCTL_BUFFER) { 192 CERROR("OBD ioctl: ioc_len larger than %d\n", 193 OBD_MAX_IOCTL_BUFFER); 194 return 1; 195 } 196 if (data->ioc_inllen1 > OBD_MAX_IOCTL_BUFFER) { 197 CERROR("OBD ioctl: ioc_inllen1 larger than ioc_len\n"); 198 return 1; 199 } 200 if (data->ioc_inllen2 > OBD_MAX_IOCTL_BUFFER) { 201 CERROR("OBD ioctl: ioc_inllen2 larger than ioc_len\n"); 202 return 1; 203 } 204 if (data->ioc_inllen3 > OBD_MAX_IOCTL_BUFFER) { 205 CERROR("OBD ioctl: ioc_inllen3 larger than ioc_len\n"); 206 return 1; 207 } 208 if (data->ioc_inllen4 > OBD_MAX_IOCTL_BUFFER) { 209 CERROR("OBD ioctl: ioc_inllen4 larger than ioc_len\n"); 210 return 1; 211 } 212 if (data->ioc_inlbuf1 && !data->ioc_inllen1) { 213 CERROR("OBD ioctl: inlbuf1 pointer but 0 length\n"); 214 return 1; 215 } 216 if (data->ioc_inlbuf2 && !data->ioc_inllen2) { 217 CERROR("OBD ioctl: inlbuf2 pointer but 0 length\n"); 218 return 1; 219 } 220 if (data->ioc_inlbuf3 && !data->ioc_inllen3) { 221 CERROR("OBD ioctl: inlbuf3 pointer but 0 length\n"); 222 return 1; 223 } 224 if (data->ioc_inlbuf4 && !data->ioc_inllen4) { 225 CERROR("OBD ioctl: inlbuf4 pointer but 0 length\n"); 226 return 1; 227 } 228 if (data->ioc_pbuf1 && !data->ioc_plen1) { 229 CERROR("OBD ioctl: pbuf1 pointer but 0 length\n"); 230 return 1; 231 } 232 if (data->ioc_pbuf2 && !data->ioc_plen2) { 233 CERROR("OBD ioctl: pbuf2 pointer but 0 length\n"); 234 return 1; 235 } 236 if (data->ioc_plen1 && !data->ioc_pbuf1) { 237 CERROR("OBD ioctl: plen1 set but NULL pointer\n"); 238 return 1; 239 } 240 if (data->ioc_plen2 && !data->ioc_pbuf2) { 241 CERROR("OBD ioctl: plen2 set but NULL pointer\n"); 242 return 1; 243 } 244 if (obd_ioctl_packlen(data) > data->ioc_len) { 245 CERROR("OBD ioctl: packlen exceeds ioc_len (%d > %d)\n", 246 obd_ioctl_packlen(data), data->ioc_len); 247 return 1; 248 } 249 return 0; 250} 251 252 253#include "obd_support.h" 254 255/* function defined in lustre/obdclass/<platform>/<platform>-module.c */ 256int obd_ioctl_getdata(char **buf, int *len, void *arg); 257int obd_ioctl_popdata(void *arg, void *data, int len); 258 259static inline void obd_ioctl_freedata(char *buf, int len) 260{ 261 OBD_FREE_LARGE(buf, len); 262 return; 263} 264 265/* 266 * BSD ioctl description: 267 * #define IOC_V1 _IOR(g, n1, long) 268 * #define IOC_V2 _IOW(g, n2, long) 269 * 270 * ioctl(f, IOC_V1, arg); 271 * arg will be treated as a long value, 272 * 273 * ioctl(f, IOC_V2, arg) 274 * arg will be treated as a pointer, bsd will call 275 * copyin(buf, arg, sizeof(long)) 276 * 277 * To make BSD ioctl handles argument correctly and simplely, 278 * we change _IOR to _IOWR so BSD will copyin obd_ioctl_data 279 * for us. Does this change affect Linux? (XXX Liang) 280 */ 281#define OBD_IOC_DATA_TYPE long 282 283#define OBD_IOC_CREATE _IOWR('f', 101, OBD_IOC_DATA_TYPE) 284#define OBD_IOC_DESTROY _IOW ('f', 104, OBD_IOC_DATA_TYPE) 285#define OBD_IOC_PREALLOCATE _IOWR('f', 105, OBD_IOC_DATA_TYPE) 286 287#define OBD_IOC_SETATTR _IOW ('f', 107, OBD_IOC_DATA_TYPE) 288#define OBD_IOC_GETATTR _IOWR ('f', 108, OBD_IOC_DATA_TYPE) 289#define OBD_IOC_READ _IOWR('f', 109, OBD_IOC_DATA_TYPE) 290#define OBD_IOC_WRITE _IOWR('f', 110, OBD_IOC_DATA_TYPE) 291 292 293#define OBD_IOC_STATFS _IOWR('f', 113, OBD_IOC_DATA_TYPE) 294#define OBD_IOC_SYNC _IOW ('f', 114, OBD_IOC_DATA_TYPE) 295#define OBD_IOC_READ2 _IOWR('f', 115, OBD_IOC_DATA_TYPE) 296#define OBD_IOC_FORMAT _IOWR('f', 116, OBD_IOC_DATA_TYPE) 297#define OBD_IOC_PARTITION _IOWR('f', 117, OBD_IOC_DATA_TYPE) 298#define OBD_IOC_COPY _IOWR('f', 120, OBD_IOC_DATA_TYPE) 299#define OBD_IOC_MIGR _IOWR('f', 121, OBD_IOC_DATA_TYPE) 300#define OBD_IOC_PUNCH _IOWR('f', 122, OBD_IOC_DATA_TYPE) 301 302#define OBD_IOC_MODULE_DEBUG _IOWR('f', 124, OBD_IOC_DATA_TYPE) 303#define OBD_IOC_BRW_READ _IOWR('f', 125, OBD_IOC_DATA_TYPE) 304#define OBD_IOC_BRW_WRITE _IOWR('f', 126, OBD_IOC_DATA_TYPE) 305#define OBD_IOC_NAME2DEV _IOWR('f', 127, OBD_IOC_DATA_TYPE) 306#define OBD_IOC_UUID2DEV _IOWR('f', 130, OBD_IOC_DATA_TYPE) 307 308#define OBD_IOC_GETNAME _IOWR('f', 131, OBD_IOC_DATA_TYPE) 309#define OBD_IOC_GETMDNAME _IOR('f', 131, char[MAX_OBD_NAME]) 310#define OBD_IOC_GETDTNAME OBD_IOC_GETNAME 311 312#define OBD_IOC_LOV_GET_CONFIG _IOWR('f', 132, OBD_IOC_DATA_TYPE) 313#define OBD_IOC_CLIENT_RECOVER _IOW ('f', 133, OBD_IOC_DATA_TYPE) 314#define OBD_IOC_PING_TARGET _IOW ('f', 136, OBD_IOC_DATA_TYPE) 315 316#define OBD_IOC_DEC_FS_USE_COUNT _IO ('f', 139 ) 317#define OBD_IOC_NO_TRANSNO _IOW ('f', 140, OBD_IOC_DATA_TYPE) 318#define OBD_IOC_SET_READONLY _IOW ('f', 141, OBD_IOC_DATA_TYPE) 319#define OBD_IOC_ABORT_RECOVERY _IOR ('f', 142, OBD_IOC_DATA_TYPE) 320 321#define OBD_IOC_ROOT_SQUASH _IOWR('f', 143, OBD_IOC_DATA_TYPE) 322 323#define OBD_GET_VERSION _IOWR ('f', 144, OBD_IOC_DATA_TYPE) 324 325#define OBD_IOC_GSS_SUPPORT _IOWR('f', 145, OBD_IOC_DATA_TYPE) 326 327#define OBD_IOC_CLOSE_UUID _IOWR ('f', 147, OBD_IOC_DATA_TYPE) 328 329#define OBD_IOC_CHANGELOG_SEND _IOW ('f', 148, OBD_IOC_DATA_TYPE) 330#define OBD_IOC_GETDEVICE _IOWR ('f', 149, OBD_IOC_DATA_TYPE) 331#define OBD_IOC_FID2PATH _IOWR ('f', 150, OBD_IOC_DATA_TYPE) 332/* see also <lustre/lustre_user.h> for ioctls 151-153 */ 333/* OBD_IOC_LOV_SETSTRIPE: See also LL_IOC_LOV_SETSTRIPE */ 334#define OBD_IOC_LOV_SETSTRIPE _IOW ('f', 154, OBD_IOC_DATA_TYPE) 335/* OBD_IOC_LOV_GETSTRIPE: See also LL_IOC_LOV_GETSTRIPE */ 336#define OBD_IOC_LOV_GETSTRIPE _IOW ('f', 155, OBD_IOC_DATA_TYPE) 337/* OBD_IOC_LOV_SETEA: See also LL_IOC_LOV_SETEA */ 338#define OBD_IOC_LOV_SETEA _IOW ('f', 156, OBD_IOC_DATA_TYPE) 339/* see <lustre/lustre_user.h> for ioctls 157-159 */ 340/* OBD_IOC_QUOTACHECK: See also LL_IOC_QUOTACHECK */ 341#define OBD_IOC_QUOTACHECK _IOW ('f', 160, int) 342/* OBD_IOC_POLL_QUOTACHECK: See also LL_IOC_POLL_QUOTACHECK */ 343#define OBD_IOC_POLL_QUOTACHECK _IOR ('f', 161, struct if_quotacheck *) 344/* OBD_IOC_QUOTACTL: See also LL_IOC_QUOTACTL */ 345#define OBD_IOC_QUOTACTL _IOWR('f', 162, struct if_quotactl) 346/* see also <lustre/lustre_user.h> for ioctls 163-176 */ 347#define OBD_IOC_CHANGELOG_REG _IOW ('f', 177, struct obd_ioctl_data) 348#define OBD_IOC_CHANGELOG_DEREG _IOW ('f', 178, struct obd_ioctl_data) 349#define OBD_IOC_CHANGELOG_CLEAR _IOW ('f', 179, struct obd_ioctl_data) 350#define OBD_IOC_RECORD _IOWR('f', 180, OBD_IOC_DATA_TYPE) 351#define OBD_IOC_ENDRECORD _IOWR('f', 181, OBD_IOC_DATA_TYPE) 352#define OBD_IOC_PARSE _IOWR('f', 182, OBD_IOC_DATA_TYPE) 353#define OBD_IOC_DORECORD _IOWR('f', 183, OBD_IOC_DATA_TYPE) 354#define OBD_IOC_PROCESS_CFG _IOWR('f', 184, OBD_IOC_DATA_TYPE) 355#define OBD_IOC_DUMP_LOG _IOWR('f', 185, OBD_IOC_DATA_TYPE) 356#define OBD_IOC_CLEAR_LOG _IOWR('f', 186, OBD_IOC_DATA_TYPE) 357#define OBD_IOC_PARAM _IOW ('f', 187, OBD_IOC_DATA_TYPE) 358#define OBD_IOC_POOL _IOWR('f', 188, OBD_IOC_DATA_TYPE) 359#define OBD_IOC_REPLACE_NIDS _IOWR('f', 189, OBD_IOC_DATA_TYPE) 360 361#define OBD_IOC_CATLOGLIST _IOWR('f', 190, OBD_IOC_DATA_TYPE) 362#define OBD_IOC_LLOG_INFO _IOWR('f', 191, OBD_IOC_DATA_TYPE) 363#define OBD_IOC_LLOG_PRINT _IOWR('f', 192, OBD_IOC_DATA_TYPE) 364#define OBD_IOC_LLOG_CANCEL _IOWR('f', 193, OBD_IOC_DATA_TYPE) 365#define OBD_IOC_LLOG_REMOVE _IOWR('f', 194, OBD_IOC_DATA_TYPE) 366#define OBD_IOC_LLOG_CHECK _IOWR('f', 195, OBD_IOC_DATA_TYPE) 367/* OBD_IOC_LLOG_CATINFO is deprecated */ 368#define OBD_IOC_LLOG_CATINFO _IOWR('f', 196, OBD_IOC_DATA_TYPE) 369 370#define ECHO_IOC_GET_STRIPE _IOWR('f', 200, OBD_IOC_DATA_TYPE) 371#define ECHO_IOC_SET_STRIPE _IOWR('f', 201, OBD_IOC_DATA_TYPE) 372#define ECHO_IOC_ENQUEUE _IOWR('f', 202, OBD_IOC_DATA_TYPE) 373#define ECHO_IOC_CANCEL _IOWR('f', 203, OBD_IOC_DATA_TYPE) 374 375#define OBD_IOC_GET_OBJ_VERSION _IOR('f', 210, OBD_IOC_DATA_TYPE) 376 377/* <lustre/lustre_user.h> defines ioctl number 218-219 */ 378#define OBD_IOC_GET_MNTOPT _IOW('f', 220, mntopt_t) 379 380#define OBD_IOC_ECHO_MD _IOR('f', 221, struct obd_ioctl_data) 381#define OBD_IOC_ECHO_ALLOC_SEQ _IOWR('f', 222, struct obd_ioctl_data) 382 383#define OBD_IOC_START_LFSCK _IOWR('f', 230, OBD_IOC_DATA_TYPE) 384#define OBD_IOC_STOP_LFSCK _IOW('f', 231, OBD_IOC_DATA_TYPE) 385#define OBD_IOC_PAUSE_LFSCK _IOW('f', 232, OBD_IOC_DATA_TYPE) 386 387/* XXX _IOWR('f', 250, long) has been defined in 388 * libcfs/include/libcfs/libcfs_private.h for debug, don't use it 389 */ 390 391/* Until such time as we get_info the per-stripe maximum from the OST, 392 * we define this to be 2T - 4k, which is the ext3 maxbytes. */ 393#define LUSTRE_STRIPE_MAXBYTES 0x1fffffff000ULL 394 395/* Special values for remove LOV EA from disk */ 396#define LOVEA_DELETE_VALUES(size, count, offset) (size == 0 && count == 0 && \ 397 offset == (typeof(offset))(-1)) 398 399/* #define POISON_BULK 0 */ 400 401/* 402 * l_wait_event is a flexible sleeping function, permitting simple caller 403 * configuration of interrupt and timeout sensitivity along with actions to 404 * be performed in the event of either exception. 405 * 406 * The first form of usage looks like this: 407 * 408 * struct l_wait_info lwi = LWI_TIMEOUT_INTR(timeout, timeout_handler, 409 * intr_handler, callback_data); 410 * rc = l_wait_event(waitq, condition, &lwi); 411 * 412 * l_wait_event() makes the current process wait on 'waitq' until 'condition' 413 * is TRUE or a "killable" signal (SIGTERM, SIKGILL, SIGINT) is pending. It 414 * returns 0 to signify 'condition' is TRUE, but if a signal wakes it before 415 * 'condition' becomes true, it optionally calls the specified 'intr_handler' 416 * if not NULL, and returns -EINTR. 417 * 418 * If a non-zero timeout is specified, signals are ignored until the timeout 419 * has expired. At this time, if 'timeout_handler' is not NULL it is called. 420 * If it returns FALSE l_wait_event() continues to wait as described above with 421 * signals enabled. Otherwise it returns -ETIMEDOUT. 422 * 423 * LWI_INTR(intr_handler, callback_data) is shorthand for 424 * LWI_TIMEOUT_INTR(0, NULL, intr_handler, callback_data) 425 * 426 * The second form of usage looks like this: 427 * 428 * struct l_wait_info lwi = LWI_TIMEOUT(timeout, timeout_handler); 429 * rc = l_wait_event(waitq, condition, &lwi); 430 * 431 * This form is the same as the first except that it COMPLETELY IGNORES 432 * SIGNALS. The caller must therefore beware that if 'timeout' is zero, or if 433 * 'timeout_handler' is not NULL and returns FALSE, then the ONLY thing that 434 * can unblock the current process is 'condition' becoming TRUE. 435 * 436 * Another form of usage is: 437 * struct l_wait_info lwi = LWI_TIMEOUT_INTERVAL(timeout, interval, 438 * timeout_handler); 439 * rc = l_wait_event(waitq, condition, &lwi); 440 * This is the same as previous case, but condition is checked once every 441 * 'interval' jiffies (if non-zero). 442 * 443 * Subtle synchronization point: this macro does *not* necessary takes 444 * wait-queue spin-lock before returning, and, hence, following idiom is safe 445 * ONLY when caller provides some external locking: 446 * 447 * Thread1 Thread2 448 * 449 * l_wait_event(&obj->wq, ....); (1) 450 * 451 * wake_up(&obj->wq): (2) 452 * spin_lock(&q->lock); (2.1) 453 * __wake_up_common(q, ...); (2.2) 454 * spin_unlock(&q->lock, flags); (2.3) 455 * 456 * OBD_FREE_PTR(obj); (3) 457 * 458 * As l_wait_event() may "short-cut" execution and return without taking 459 * wait-queue spin-lock, some additional synchronization is necessary to 460 * guarantee that step (3) can begin only after (2.3) finishes. 461 * 462 * XXX nikita: some ptlrpc daemon threads have races of that sort. 463 * 464 */ 465static inline int back_to_sleep(void *arg) 466{ 467 return 0; 468} 469 470#define LWI_ON_SIGNAL_NOOP ((void (*)(void *))(-1)) 471 472struct l_wait_info { 473 long lwi_timeout; 474 long lwi_interval; 475 int lwi_allow_intr; 476 int (*lwi_on_timeout)(void *); 477 void (*lwi_on_signal)(void *); 478 void *lwi_cb_data; 479}; 480 481/* NB: LWI_TIMEOUT ignores signals completely */ 482#define LWI_TIMEOUT(time, cb, data) \ 483((struct l_wait_info) { \ 484 .lwi_timeout = time, \ 485 .lwi_on_timeout = cb, \ 486 .lwi_cb_data = data, \ 487 .lwi_interval = 0, \ 488 .lwi_allow_intr = 0 \ 489}) 490 491#define LWI_TIMEOUT_INTERVAL(time, interval, cb, data) \ 492((struct l_wait_info) { \ 493 .lwi_timeout = time, \ 494 .lwi_on_timeout = cb, \ 495 .lwi_cb_data = data, \ 496 .lwi_interval = interval, \ 497 .lwi_allow_intr = 0 \ 498}) 499 500#define LWI_TIMEOUT_INTR(time, time_cb, sig_cb, data) \ 501((struct l_wait_info) { \ 502 .lwi_timeout = time, \ 503 .lwi_on_timeout = time_cb, \ 504 .lwi_on_signal = sig_cb, \ 505 .lwi_cb_data = data, \ 506 .lwi_interval = 0, \ 507 .lwi_allow_intr = 0 \ 508}) 509 510#define LWI_TIMEOUT_INTR_ALL(time, time_cb, sig_cb, data) \ 511((struct l_wait_info) { \ 512 .lwi_timeout = time, \ 513 .lwi_on_timeout = time_cb, \ 514 .lwi_on_signal = sig_cb, \ 515 .lwi_cb_data = data, \ 516 .lwi_interval = 0, \ 517 .lwi_allow_intr = 1 \ 518}) 519 520#define LWI_INTR(cb, data) LWI_TIMEOUT_INTR(0, NULL, cb, data) 521 522#define LUSTRE_FATAL_SIGS (sigmask(SIGKILL) | sigmask(SIGINT) | \ 523 sigmask(SIGTERM) | sigmask(SIGQUIT) | \ 524 sigmask(SIGALRM)) 525 526 527/* 528 * wait for @condition to become true, but no longer than timeout, specified 529 * by @info. 530 */ 531#define __l_wait_event(wq, condition, info, ret, l_add_wait) \ 532do { \ 533 wait_queue_t __wait; \ 534 long __timeout = info->lwi_timeout; \ 535 sigset_t __blocked; \ 536 int __allow_intr = info->lwi_allow_intr; \ 537 \ 538 ret = 0; \ 539 if (condition) \ 540 break; \ 541 \ 542 init_waitqueue_entry(&__wait, current); \ 543 l_add_wait(&wq, &__wait); \ 544 \ 545 /* Block all signals (just the non-fatal ones if no timeout). */ \ 546 if (info->lwi_on_signal != NULL && (__timeout == 0 || __allow_intr)) \ 547 __blocked = cfs_block_sigsinv(LUSTRE_FATAL_SIGS); \ 548 else \ 549 __blocked = cfs_block_sigsinv(0); \ 550 \ 551 for (;;) { \ 552 unsigned __wstate; \ 553 \ 554 __wstate = info->lwi_on_signal != NULL && \ 555 (__timeout == 0 || __allow_intr) ? \ 556 TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE; \ 557 \ 558 set_current_state(TASK_INTERRUPTIBLE); \ 559 \ 560 if (condition) \ 561 break; \ 562 \ 563 if (__timeout == 0) { \ 564 schedule(); \ 565 } else { \ 566 long interval = info->lwi_interval? \ 567 min_t(long, \ 568 info->lwi_interval,__timeout):\ 569 __timeout; \ 570 long remaining = schedule_timeout(interval);\ 571 __timeout = cfs_time_sub(__timeout, \ 572 cfs_time_sub(interval, remaining));\ 573 if (__timeout == 0) { \ 574 if (info->lwi_on_timeout == NULL || \ 575 info->lwi_on_timeout(info->lwi_cb_data)) { \ 576 ret = -ETIMEDOUT; \ 577 break; \ 578 } \ 579 /* Take signals after the timeout expires. */ \ 580 if (info->lwi_on_signal != NULL) \ 581 (void)cfs_block_sigsinv(LUSTRE_FATAL_SIGS);\ 582 } \ 583 } \ 584 \ 585 if (condition) \ 586 break; \ 587 if (cfs_signal_pending()) { \ 588 if (info->lwi_on_signal != NULL && \ 589 (__timeout == 0 || __allow_intr)) { \ 590 if (info->lwi_on_signal != LWI_ON_SIGNAL_NOOP) \ 591 info->lwi_on_signal(info->lwi_cb_data);\ 592 ret = -EINTR; \ 593 break; \ 594 } \ 595 /* We have to do this here because some signals */ \ 596 /* are not blockable - ie from strace(1). */ \ 597 /* In these cases we want to schedule_timeout() */ \ 598 /* again, because we don't want that to return */ \ 599 /* -EINTR when the RPC actually succeeded. */ \ 600 /* the recalc_sigpending() below will deliver the */ \ 601 /* signal properly. */ \ 602 cfs_clear_sigpending(); \ 603 } \ 604 } \ 605 \ 606 cfs_restore_sigs(__blocked); \ 607 \ 608 set_current_state(TASK_RUNNING); \ 609 remove_wait_queue(&wq, &__wait); \ 610} while (0) 611 612 613 614#define l_wait_event(wq, condition, info) \ 615({ \ 616 int __ret; \ 617 struct l_wait_info *__info = (info); \ 618 \ 619 __l_wait_event(wq, condition, __info, \ 620 __ret, add_wait_queue); \ 621 __ret; \ 622}) 623 624#define l_wait_event_exclusive(wq, condition, info) \ 625({ \ 626 int __ret; \ 627 struct l_wait_info *__info = (info); \ 628 \ 629 __l_wait_event(wq, condition, __info, \ 630 __ret, add_wait_queue_exclusive); \ 631 __ret; \ 632}) 633 634#define l_wait_event_exclusive_head(wq, condition, info) \ 635({ \ 636 int __ret; \ 637 struct l_wait_info *__info = (info); \ 638 \ 639 __l_wait_event(wq, condition, __info, \ 640 __ret, add_wait_queue_exclusive_head); \ 641 __ret; \ 642}) 643 644#define l_wait_condition(wq, condition) \ 645({ \ 646 struct l_wait_info lwi = { 0 }; \ 647 l_wait_event(wq, condition, &lwi); \ 648}) 649 650#define l_wait_condition_exclusive(wq, condition) \ 651({ \ 652 struct l_wait_info lwi = { 0 }; \ 653 l_wait_event_exclusive(wq, condition, &lwi); \ 654}) 655 656#define l_wait_condition_exclusive_head(wq, condition) \ 657({ \ 658 struct l_wait_info lwi = { 0 }; \ 659 l_wait_event_exclusive_head(wq, condition, &lwi); \ 660}) 661 662#define LIBLUSTRE_CLIENT (0) 663 664/** @} lib */ 665 666#endif /* _LUSTRE_LIB_H */ 667