-/*
- * GPL HEADER START
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 only,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License version 2 for more details (a copy is included
- * in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see
- * http://www.gnu.org/licenses/gpl-2.0.html
- *
- * GPL HEADER END
- */
-/*
- * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+
+/* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
* Copyright (c) 2012, 2017, Intel Corporation.
*/
-/*
- * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
- */
+
+/* This file is part of Lustre, http://www.lustre.org/ */
#ifndef __UAPI_LNET_TYPES_H__
#define __UAPI_LNET_TYPES_H__
+#include <linux/types.h>
+#include <linux/string.h>
+#include <asm/byteorder.h>
+#ifndef __KERNEL__
+#include <stdbool.h>
+#endif
+
/** \addtogroup lnet
* @{ */
#define LNET_RESERVED_PORTAL 0
/** wildcard NID that matches any end-point address */
-#define LNET_NID_ANY ((lnet_nid_t) -1)
+#define LNET_NID_ANY (~(lnet_nid_t) 0)
/** wildcard PID that matches any lnet_pid_t */
-#define LNET_PID_ANY ((lnet_pid_t) -1)
+#define LNET_PID_ANY (~(lnet_pid_t) 0)
+
+static inline int LNET_NID_IS_ANY(const struct lnet_nid *nid)
+{
+ /* A NULL pointer can be used to mean "ANY" */
+ return !nid || nid->nid_type == 0xFF;
+}
+
+#define LNET_ANY_NID ((struct lnet_nid) \
+ {0xFF, 0xFF, ~0, {~0, ~0, ~0, ~0} })
#define LNET_PID_RESERVED 0xf0000000 /* reserved bits in PID */
#define LNET_PID_USERFLAG 0x80000000 /* set in userspace peers */
return (nid >> 32) & 0xffffffff;
}
-static inline lnet_nid_t LNET_MKNID(__u32 net, __u32 addr)
-{
- return (((__u64)net) << 32) | addr;
-}
-
static inline __u32 LNET_NETNUM(__u32 net)
{
return net & 0xffff;
static inline __u32 LNET_NETTYP(__u32 net)
{
- return (net >> 16) & 0xffff;
+ return (net >> 16) & 0xff;
}
static inline __u32 LNET_MKNET(__u32 type, __u32 num)
return (type << 16) | num;
}
+static inline lnet_nid_t LNET_MKNID(__u32 net, __u32 addr)
+{
+ return (((__u64)net) << 32) | addr;
+}
+
/** The lolnd NID (i.e. myself) */
#define LNET_NID_LO_0 LNET_MKNID(LNET_MKNET(LOLND, 0), 0)
#define LNET_NET_ANY LNET_NIDNET(LNET_NID_ANY)
+static inline bool nid_is_nid4(const struct lnet_nid *nid)
+{
+ return NID_ADDR_BYTES(nid) == 4;
+}
+
+/* check for address set */
+static inline bool nid_addr_is_set(const struct lnet_nid *nid)
+{
+ __u8 *addr = (__u8 *)(&nid->nid_addr[0]);
+ int i;
+
+ for (i = 0; i < NID_ADDR_BYTES(nid); i++)
+ if (addr[i])
+ return true;
+
+ return false;
+}
+
+/* LOLND may not be defined yet, so we cannot use an inline */
+#define nid_is_lo0(__nid) \
+ ((__nid)->nid_type == LOLND && \
+ nid_is_nid4(__nid) && \
+ (__nid)->nid_num == 0 && \
+ (__nid)->nid_addr[0] == 0)
+
+static inline __u32 LNET_NID_NET(const struct lnet_nid *nid)
+{
+ if (LNET_NID_IS_ANY(nid))
+ return LNET_NET_ANY;
+ else
+ return LNET_MKNET(nid->nid_type, __be16_to_cpu(nid->nid_num));
+}
+
+static inline void lnet_nid4_to_nid(lnet_nid_t nid4, struct lnet_nid *nid)
+{
+ if (nid4 == LNET_NID_ANY) {
+ *nid = LNET_ANY_NID;
+ return;
+ }
+
+ nid->nid_size = 0;
+ nid->nid_type = LNET_NETTYP(LNET_NIDNET(nid4));
+ nid->nid_num = __cpu_to_be16(LNET_NETNUM(LNET_NIDNET(nid4)));
+ nid->nid_addr[0] = __cpu_to_be32(LNET_NIDADDR(nid4));
+ nid->nid_addr[1] = nid->nid_addr[2] = nid->nid_addr[3] = 0;
+}
+
+static inline lnet_nid_t lnet_nid_to_nid4(const struct lnet_nid *nid)
+{
+ if (LNET_NID_IS_ANY(nid))
+ return LNET_NID_ANY;
+
+ return LNET_MKNID(LNET_NID_NET(nid), __be32_to_cpu(nid->nid_addr[0]));
+}
+
+static inline int nid_same(const struct lnet_nid *n1,
+ const struct lnet_nid *n2)
+{
+ return n1->nid_size == n2->nid_size &&
+ n1->nid_type == n2->nid_type &&
+ n1->nid_num == n2->nid_num &&
+ n1->nid_addr[0] == n2->nid_addr[0] &&
+ n1->nid_addr[1] == n2->nid_addr[1] &&
+ n1->nid_addr[2] == n2->nid_addr[2] &&
+ n1->nid_addr[3] == n2->nid_addr[3];
+}
+
+/* This can be used when we need to hash a nid */
+static inline unsigned long nidhash(const struct lnet_nid *nid)
+{
+ int i;
+ unsigned long hash = 0;
+
+ hash ^= LNET_NID_NET(nid);
+ for (i = 0; i < 4; i++)
+ hash ^= nid->nid_addr[i];
+ return hash;
+}
+
struct lnet_counters_health {
__u32 lch_rst_alloc;
__u32 lch_resend_count;
* 'me' for match entry). Each type of object is given a unique handle type
* to enhance type checking.
*/
-#define LNET_WIRE_HANDLE_COOKIE_NONE (-1)
+#define LNET_WIRE_HANDLE_COOKIE_NONE (~0ULL)
struct lnet_handle_md {
__u64 cookie;
/** process id */
lnet_pid_t pid;
};
+
+/**
+ * Global process ID - with large addresses
+ */
+struct lnet_processid {
+ /** node id */
+ struct lnet_nid nid;
+ /** process id */
+ lnet_pid_t pid;
+};
+
+static inline void
+lnet_pid4_to_pid(struct lnet_process_id pid4, struct lnet_processid *pid)
+{
+ pid->pid = pid4.pid;
+ lnet_nid4_to_nid(pid4.nid, &pid->nid);
+}
+
+static inline struct lnet_process_id
+lnet_pid_to_pid4(struct lnet_processid *pid)
+{
+ struct lnet_process_id ret;
+
+ ret.pid = pid->pid;
+ ret.nid = lnet_nid_to_nid4(&pid->nid);
+ return ret;
+}
+
/** @} lnet_addr */
/** \addtogroup lnet_me
/** \addtogroup lnet_md
* @{ */
+struct lnet_hdr_nid16 {
+ char _bytes[sizeof(struct lnet_hdr)];
+} __attribute__((packed));
+
/**
* Event queue handler function type.
*
* regardless of the value of the lnet_response_tracking param.
* - LNET_MD_NO_TRACK_RESPONSE: Disable response tracking on this MD
* regardless of the value of the lnet_response_tracking param.
+ * - LNET_MD_GNILND: Disable warning about exceeding LNET_MAX_IOV.
*
* Note:
* - LNET_MD_KIOV allows for a scatter/gather capability for memory
#define LNET_MD_TRACK_RESPONSE (1 << 10)
/** See struct lnet_md::options. */
#define LNET_MD_NO_TRACK_RESPONSE (1 << 11)
-
-/* For compatibility with Cray Portals */
-#define LNET_MD_PHYS 0
+/** See struct lnet_md::options. */
+#define LNET_MD_GNILND (1 << 12)
+/** Special page mapping handling */
+#define LNET_MD_GPU_ADDR (1 << 13)
/** Infinite threshold on MD operations. See struct lnet_md::threshold */
#define LNET_MD_THRESH_INF (-1)
*/
struct lnet_event {
/** The identifier (nid, pid) of the target. */
- struct lnet_process_id target;
+ struct lnet_processid target;
/** The identifier (nid, pid) of the initiator. */
- struct lnet_process_id initiator;
+ struct lnet_processid initiator;
/** The source NID on the initiator. */
- struct lnet_process_id source;
+ struct lnet_processid source;
/**
* The NID of the immediate sender. If the request has been forwarded
* by routers, this is the NID of the last hop; otherwise it's the
* same as the source.
*/
- lnet_nid_t sender;
+ struct lnet_nid sender;
/** Indicates the type of the event. */
enum lnet_event_kind type;
/** The portal table index specified in the request */
- unsigned int pt_index;
+ unsigned int pt_index;
/** A copy of the match bits specified in the request. */
- __u64 match_bits;
+ __u64 match_bits;
/** The length (in bytes) specified in the request. */
- unsigned int rlength;
+ unsigned int rlength;
/**
* The length (in bytes) of the data that was manipulated by the
* operation. For truncated operations, the manipulated length will be
* see struct lnet_md). For all other operations, the manipulated length
* will be the length of the requested operation, i.e. rlength.
*/
- unsigned int mlength;
+ unsigned int mlength;
/**
* The handle to the MD associated with the event. The handle may be
* invalid if the MD has been unlinked.
* 64 bits of out-of-band user data. Only valid for LNET_EVENT_PUT.
* \see LNetPut
*/
- __u64 hdr_data;
+ __u64 hdr_data;
/**
* The message type, to ensure a handler for LNET_EVENT_SEND can
* distinguish between LNET_MSG_GET and LNET_MSG_PUT.
*/
- __u32 msg_type;
+ __u32 msg_type;
/**
* Indicates the completion status of the operation. It's 0 for
* successful operations, otherwise it's an error code.
*/
- int status;
+ int status;
/**
* Indicates whether the MD has been unlinked. Note that:
* - An event with unlinked set is the last event on the MD.
* - This field is also set for an explicit LNET_EVENT_UNLINK event.
* \see LNetMDUnlink
*/
- int unlinked;
+ int unlinked;
/**
* The displacement (in bytes) into the memory region that the
* operation used. The offset can be determined by the operation for
* a remote managed MD or by the local MD.
* \see struct lnet_md::options
*/
- unsigned int offset;
+ unsigned int offset;
/**
* The sequence number for this event. Sequence numbers are unique
* to each event.
*/
- volatile unsigned long sequence;
+ volatile unsigned long sequence;
};
/** \addtogroup lnet_data
git://git.whamcloud.com / fs / lustre-release.git / blobdiff