Commit | Line | Data |
---|---|---|
d7e09d03 PT |
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_disk.h | |
37 | * | |
38 | * Lustre disk format definitions. | |
39 | * | |
40 | * Author: Nathan Rutman <nathan@clusterfs.com> | |
41 | */ | |
42 | ||
43 | #ifndef _LUSTRE_DISK_H | |
44 | #define _LUSTRE_DISK_H | |
45 | ||
46 | /** \defgroup disk disk | |
47 | * | |
48 | * @{ | |
49 | */ | |
50 | ||
9fdaf8c0 GKH |
51 | #include "../../include/linux/libcfs/libcfs.h" |
52 | #include "../../include/linux/lnet/types.h" | |
ac550511 | 53 | #include <linux/backing-dev.h> |
d7e09d03 PT |
54 | |
55 | /****************** on-disk files *********************/ | |
56 | ||
99a92265 | 57 | #define MDT_LOGS_DIR "LOGS" /* COMPAT_146 */ |
58 | #define MOUNT_CONFIGS_DIR "CONFIGS" | |
59 | #define CONFIGS_FILE "mountdata" | |
d7e09d03 | 60 | /** Persistent mount data are stored on the disk in this file. */ |
99a92265 | 61 | #define MOUNT_DATA_FILE MOUNT_CONFIGS_DIR"/"CONFIGS_FILE |
62 | #define LAST_RCVD "last_rcvd" | |
63 | #define LOV_OBJID "lov_objid" | |
d7e09d03 | 64 | #define LOV_OBJSEQ "lov_objseq" |
99a92265 | 65 | #define HEALTH_CHECK "health_check" |
66 | #define CAPA_KEYS "capa_keys" | |
67 | #define CHANGELOG_USERS "changelog_users" | |
68 | #define MGS_NIDTBL_DIR "NIDTBL_VERSIONS" | |
69 | #define QMT_DIR "quota_master" | |
70 | #define QSD_DIR "quota_slave" | |
71 | #define HSM_ACTIONS "hsm_actions" | |
d7e09d03 PT |
72 | |
73 | /****************** persistent mount data *********************/ | |
74 | ||
75 | #define LDD_F_SV_TYPE_MDT 0x0001 | |
76 | #define LDD_F_SV_TYPE_OST 0x0002 | |
77 | #define LDD_F_SV_TYPE_MGS 0x0004 | |
78 | #define LDD_F_SV_TYPE_MASK (LDD_F_SV_TYPE_MDT | \ | |
79 | LDD_F_SV_TYPE_OST | \ | |
80 | LDD_F_SV_TYPE_MGS) | |
81 | #define LDD_F_SV_ALL 0x0008 | |
82 | /** need an index assignment */ | |
83 | #define LDD_F_NEED_INDEX 0x0010 | |
84 | /** never registered */ | |
85 | #define LDD_F_VIRGIN 0x0020 | |
86 | /** update the config logs for this server */ | |
87 | #define LDD_F_UPDATE 0x0040 | |
88 | /** rewrite the LDD */ | |
89 | #define LDD_F_REWRITE_LDD 0x0080 | |
90 | /** regenerate config logs for this fs or server */ | |
91 | #define LDD_F_WRITECONF 0x0100 | |
92 | /** COMPAT_14 */ | |
93 | #define LDD_F_UPGRADE14 0x0200 | |
94 | /** process as lctl conf_param */ | |
95 | #define LDD_F_PARAM 0x0400 | |
96 | /** all nodes are specified as service nodes */ | |
97 | #define LDD_F_NO_PRIMNODE 0x1000 | |
98 | /** IR enable flag */ | |
99 | #define LDD_F_IR_CAPABLE 0x2000 | |
100 | /** the MGS refused to register the target. */ | |
101 | #define LDD_F_ERROR 0x4000 | |
7d4bae45 AB |
102 | /** process at lctl conf_param */ |
103 | #define LDD_F_PARAM2 0x8000 | |
d7e09d03 PT |
104 | |
105 | /* opc for target register */ | |
106 | #define LDD_F_OPC_REG 0x10000000 | |
107 | #define LDD_F_OPC_UNREG 0x20000000 | |
108 | #define LDD_F_OPC_READY 0x40000000 | |
109 | #define LDD_F_OPC_MASK 0xf0000000 | |
110 | ||
111 | #define LDD_F_ONDISK_MASK (LDD_F_SV_TYPE_MASK) | |
112 | ||
113 | #define LDD_F_MASK 0xFFFF | |
114 | ||
115 | enum ldd_mount_type { | |
116 | LDD_MT_EXT3 = 0, | |
117 | LDD_MT_LDISKFS, | |
118 | LDD_MT_SMFS, | |
119 | LDD_MT_REISERFS, | |
120 | LDD_MT_LDISKFS2, | |
121 | LDD_MT_ZFS, | |
122 | LDD_MT_LAST | |
123 | }; | |
124 | ||
125 | static inline char *mt_str(enum ldd_mount_type mt) | |
126 | { | |
127 | static char *mount_type_string[] = { | |
128 | "ext3", | |
129 | "ldiskfs", | |
130 | "smfs", | |
131 | "reiserfs", | |
132 | "ldiskfs2", | |
133 | "zfs", | |
134 | }; | |
135 | return mount_type_string[mt]; | |
136 | } | |
137 | ||
138 | static inline char *mt_type(enum ldd_mount_type mt) | |
139 | { | |
140 | static char *mount_type_string[] = { | |
141 | "osd-ldiskfs", | |
142 | "osd-ldiskfs", | |
143 | "osd-smfs", | |
144 | "osd-reiserfs", | |
145 | "osd-ldiskfs", | |
146 | "osd-zfs", | |
147 | }; | |
148 | return mount_type_string[mt]; | |
149 | } | |
150 | ||
151 | #define LDD_INCOMPAT_SUPP 0 | |
152 | #define LDD_ROCOMPAT_SUPP 0 | |
153 | ||
154 | #define LDD_MAGIC 0x1dd00001 | |
155 | ||
156 | /* On-disk configuration file. In host-endian order. */ | |
157 | struct lustre_disk_data { | |
158 | __u32 ldd_magic; | |
159 | __u32 ldd_feature_compat; /* compatible feature flags */ | |
160 | __u32 ldd_feature_rocompat;/* read-only compatible feature flags */ | |
161 | __u32 ldd_feature_incompat;/* incompatible feature flags */ | |
162 | ||
163 | __u32 ldd_config_ver; /* config rewrite count - not used */ | |
164 | __u32 ldd_flags; /* LDD_SV_TYPE */ | |
165 | __u32 ldd_svindex; /* server index (0001), must match | |
166 | svname */ | |
167 | __u32 ldd_mount_type; /* target fs type LDD_MT_* */ | |
168 | char ldd_fsname[64]; /* filesystem this server is part of, | |
169 | MTI_NAME_MAXLEN */ | |
170 | char ldd_svname[64]; /* this server's name (lustre-mdt0001)*/ | |
171 | __u8 ldd_uuid[40]; /* server UUID (COMPAT_146) */ | |
172 | ||
173 | /*200*/ char ldd_userdata[1024 - 200]; /* arbitrary user string */ | |
174 | /*1024*/__u8 ldd_padding[4096 - 1024]; | |
175 | /*4096*/char ldd_mount_opts[4096]; /* target fs mount opts */ | |
176 | /*8192*/char ldd_params[4096]; /* key=value pairs */ | |
177 | }; | |
178 | ||
179 | ||
180 | #define IS_MDT(data) ((data)->lsi_flags & LDD_F_SV_TYPE_MDT) | |
181 | #define IS_OST(data) ((data)->lsi_flags & LDD_F_SV_TYPE_OST) | |
182 | #define IS_MGS(data) ((data)->lsi_flags & LDD_F_SV_TYPE_MGS) | |
183 | #define IS_SERVER(data) ((data)->lsi_flags & (LDD_F_SV_TYPE_MGS | \ | |
184 | LDD_F_SV_TYPE_MDT | LDD_F_SV_TYPE_OST)) | |
185 | #define MT_STR(data) mt_str((data)->ldd_mount_type) | |
186 | ||
187 | /* Make the mdt/ost server obd name based on the filesystem name */ | |
188 | static inline int server_make_name(__u32 flags, __u16 index, char *fs, | |
189 | char *name) | |
190 | { | |
191 | if (flags & (LDD_F_SV_TYPE_MDT | LDD_F_SV_TYPE_OST)) { | |
192 | if (!(flags & LDD_F_SV_ALL)) | |
193 | sprintf(name, "%.8s%c%s%04x", fs, | |
194 | (flags & LDD_F_VIRGIN) ? ':' : | |
195 | ((flags & LDD_F_WRITECONF) ? '=' : '-'), | |
196 | (flags & LDD_F_SV_TYPE_MDT) ? "MDT" : "OST", | |
197 | index); | |
198 | } else if (flags & LDD_F_SV_TYPE_MGS) { | |
199 | sprintf(name, "MGS"); | |
200 | } else { | |
201 | CERROR("unknown server type %#x\n", flags); | |
202 | return 1; | |
203 | } | |
204 | return 0; | |
205 | } | |
206 | ||
207 | /****************** mount command *********************/ | |
208 | ||
209 | /* The lmd is only used internally by Lustre; mount simply passes | |
210 | everything as string options */ | |
211 | ||
212 | #define LMD_MAGIC 0xbdacbd03 | |
213 | ||
214 | /* gleaned from the mount command - no persistent info here */ | |
215 | struct lustre_mount_data { | |
216 | __u32 lmd_magic; | |
217 | __u32 lmd_flags; /* lustre mount flags */ | |
218 | int lmd_mgs_failnodes; /* mgs failover node count */ | |
219 | int lmd_exclude_count; | |
220 | int lmd_recovery_time_soft; | |
221 | int lmd_recovery_time_hard; | |
222 | char *lmd_dev; /* device name */ | |
223 | char *lmd_profile; /* client only */ | |
224 | char *lmd_mgssec; /* sptlrpc flavor to mgs */ | |
225 | char *lmd_opts; /* lustre mount options (as opposed to | |
226 | _device_ mount options) */ | |
227 | char *lmd_params; /* lustre params */ | |
228 | __u32 *lmd_exclude; /* array of OSTs to ignore */ | |
229 | char *lmd_mgs; /* MGS nid */ | |
230 | char *lmd_osd_type; /* OSD type */ | |
231 | }; | |
232 | ||
99a92265 | 233 | #define LMD_FLG_SERVER 0x0001 /* Mounting a server */ |
234 | #define LMD_FLG_CLIENT 0x0002 /* Mounting a client */ | |
235 | #define LMD_FLG_ABORT_RECOV 0x0008 /* Abort recovery */ | |
236 | #define LMD_FLG_NOSVC 0x0010 /* Only start MGS/MGC for servers, | |
237 | no other services */ | |
238 | #define LMD_FLG_NOMGS 0x0020 /* Only start target for servers, reusing | |
239 | existing MGS services */ | |
240 | #define LMD_FLG_WRITECONF 0x0040 /* Rewrite config log */ | |
241 | #define LMD_FLG_NOIR 0x0080 /* NO imperative recovery */ | |
242 | #define LMD_FLG_NOSCRUB 0x0100 /* Do not trigger scrub automatically */ | |
243 | #define LMD_FLG_MGS 0x0200 /* Also start MGS along with server */ | |
244 | #define LMD_FLG_IAM 0x0400 /* IAM dir */ | |
245 | #define LMD_FLG_NO_PRIMNODE 0x0800 /* all nodes are service nodes */ | |
246 | #define LMD_FLG_VIRGIN 0x1000 /* the service registers first time */ | |
247 | #define LMD_FLG_UPDATE 0x2000 /* update parameters */ | |
248 | #define LMD_FLG_HSM 0x4000 /* Start coordinator */ | |
d7e09d03 PT |
249 | |
250 | #define lmd_is_client(x) ((x)->lmd_flags & LMD_FLG_CLIENT) | |
251 | ||
252 | ||
253 | /****************** last_rcvd file *********************/ | |
254 | ||
255 | /** version recovery epoch */ | |
256 | #define LR_EPOCH_BITS 32 | |
257 | #define lr_epoch(a) ((a) >> LR_EPOCH_BITS) | |
258 | #define LR_EXPIRE_INTERVALS 16 /**< number of intervals to track transno */ | |
259 | #define ENOENT_VERSION 1 /** 'virtual' version of non-existent object */ | |
260 | ||
261 | #define LR_SERVER_SIZE 512 | |
262 | #define LR_CLIENT_START 8192 | |
263 | #define LR_CLIENT_SIZE 128 | |
264 | #if LR_CLIENT_START < LR_SERVER_SIZE | |
265 | #error "Can't have LR_CLIENT_START < LR_SERVER_SIZE" | |
266 | #endif | |
267 | ||
268 | /* | |
269 | * This limit is arbitrary (131072 clients on x86), but it is convenient to use | |
270 | * 2^n * PAGE_CACHE_SIZE * 8 for the number of bits that fit an order-n allocation. | |
271 | * If we need more than 131072 clients (order-2 allocation on x86) then this | |
272 | * should become an array of single-page pointers that are allocated on demand. | |
273 | */ | |
274 | #if (128 * 1024UL) > (PAGE_CACHE_SIZE * 8) | |
275 | #define LR_MAX_CLIENTS (128 * 1024UL) | |
276 | #else | |
277 | #define LR_MAX_CLIENTS (PAGE_CACHE_SIZE * 8) | |
278 | #endif | |
279 | ||
280 | /** COMPAT_146: this is an OST (temporary) */ | |
281 | #define OBD_COMPAT_OST 0x00000002 | |
282 | /** COMPAT_146: this is an MDT (temporary) */ | |
283 | #define OBD_COMPAT_MDT 0x00000004 | |
284 | /** 2.0 server, interop flag to show server version is changed */ | |
285 | #define OBD_COMPAT_20 0x00000008 | |
286 | ||
287 | /** MDS handles LOV_OBJID file */ | |
288 | #define OBD_ROCOMPAT_LOVOBJID 0x00000001 | |
289 | ||
290 | /** OST handles group subdirs */ | |
291 | #define OBD_INCOMPAT_GROUPS 0x00000001 | |
292 | /** this is an OST */ | |
293 | #define OBD_INCOMPAT_OST 0x00000002 | |
294 | /** this is an MDT */ | |
295 | #define OBD_INCOMPAT_MDT 0x00000004 | |
296 | /** common last_rvcd format */ | |
297 | #define OBD_INCOMPAT_COMMON_LR 0x00000008 | |
298 | /** FID is enabled */ | |
299 | #define OBD_INCOMPAT_FID 0x00000010 | |
300 | /** Size-on-MDS is enabled */ | |
301 | #define OBD_INCOMPAT_SOM 0x00000020 | |
302 | /** filesystem using iam format to store directory entries */ | |
303 | #define OBD_INCOMPAT_IAM_DIR 0x00000040 | |
304 | /** LMA attribute contains per-inode incompatible flags */ | |
305 | #define OBD_INCOMPAT_LMA 0x00000080 | |
306 | /** lmm_stripe_count has been shrunk from __u32 to __u16 and the remaining 16 | |
307 | * bits are now used to store a generation. Once we start changing the layout | |
308 | * and bumping the generation, old versions expecting a 32-bit lmm_stripe_count | |
309 | * will be confused by interpreting stripe_count | gen << 16 as the actual | |
310 | * stripe count */ | |
311 | #define OBD_INCOMPAT_LMM_VER 0x00000100 | |
312 | /** multiple OI files for MDT */ | |
313 | #define OBD_INCOMPAT_MULTI_OI 0x00000200 | |
314 | ||
315 | /* Data stored per server at the head of the last_rcvd file. In le32 order. | |
316 | This should be common to filter_internal.h, lustre_mds.h */ | |
317 | struct lr_server_data { | |
318 | __u8 lsd_uuid[40]; /* server UUID */ | |
319 | __u64 lsd_last_transno; /* last completed transaction ID */ | |
320 | __u64 lsd_compat14; /* reserved - compat with old last_rcvd */ | |
321 | __u64 lsd_mount_count; /* incarnation number */ | |
322 | __u32 lsd_feature_compat; /* compatible feature flags */ | |
323 | __u32 lsd_feature_rocompat;/* read-only compatible feature flags */ | |
324 | __u32 lsd_feature_incompat;/* incompatible feature flags */ | |
325 | __u32 lsd_server_size; /* size of server data area */ | |
326 | __u32 lsd_client_start; /* start of per-client data area */ | |
327 | __u16 lsd_client_size; /* size of per-client data area */ | |
328 | __u16 lsd_subdir_count; /* number of subdirectories for objects */ | |
329 | __u64 lsd_catalog_oid; /* recovery catalog object id */ | |
330 | __u32 lsd_catalog_ogen; /* recovery catalog inode generation */ | |
331 | __u8 lsd_peeruuid[40]; /* UUID of MDS associated with this OST */ | |
332 | __u32 lsd_osd_index; /* index number of OST in LOV */ | |
333 | __u32 lsd_padding1; /* was lsd_mdt_index, unused in 2.4.0 */ | |
334 | __u32 lsd_start_epoch; /* VBR: start epoch from last boot */ | |
335 | /** transaction values since lsd_trans_table_time */ | |
336 | __u64 lsd_trans_table[LR_EXPIRE_INTERVALS]; | |
337 | /** start point of transno table below */ | |
338 | __u32 lsd_trans_table_time; /* time of first slot in table above */ | |
339 | __u32 lsd_expire_intervals; /* LR_EXPIRE_INTERVALS */ | |
340 | __u8 lsd_padding[LR_SERVER_SIZE - 288]; | |
341 | }; | |
342 | ||
343 | /* Data stored per client in the last_rcvd file. In le32 order. */ | |
344 | struct lsd_client_data { | |
345 | __u8 lcd_uuid[40]; /* client UUID */ | |
346 | __u64 lcd_last_transno; /* last completed transaction ID */ | |
347 | __u64 lcd_last_xid; /* xid for the last transaction */ | |
348 | __u32 lcd_last_result; /* result from last RPC */ | |
349 | __u32 lcd_last_data; /* per-op data (disposition for open &c.) */ | |
350 | /* for MDS_CLOSE requests */ | |
351 | __u64 lcd_last_close_transno; /* last completed transaction ID */ | |
352 | __u64 lcd_last_close_xid; /* xid for the last transaction */ | |
353 | __u32 lcd_last_close_result; /* result from last RPC */ | |
354 | __u32 lcd_last_close_data; /* per-op data */ | |
355 | /* VBR: last versions */ | |
356 | __u64 lcd_pre_versions[4]; | |
357 | __u32 lcd_last_epoch; | |
358 | /** orphans handling for delayed export rely on that */ | |
359 | __u32 lcd_first_epoch; | |
360 | __u8 lcd_padding[LR_CLIENT_SIZE - 128]; | |
361 | }; | |
362 | ||
363 | /* bug20354: the lcd_uuid for export of clients may be wrong */ | |
364 | static inline void check_lcd(char *obd_name, int index, | |
365 | struct lsd_client_data *lcd) | |
366 | { | |
367 | int length = sizeof(lcd->lcd_uuid); | |
368 | if (strnlen((char*)lcd->lcd_uuid, length) == length) { | |
369 | lcd->lcd_uuid[length - 1] = '\0'; | |
370 | ||
371 | LCONSOLE_ERROR("the client UUID (%s) on %s for exports" | |
372 | "stored in last_rcvd(index = %d) is bad!\n", | |
373 | lcd->lcd_uuid, obd_name, index); | |
374 | } | |
375 | } | |
376 | ||
377 | /* last_rcvd handling */ | |
378 | static inline void lsd_le_to_cpu(struct lr_server_data *buf, | |
379 | struct lr_server_data *lsd) | |
380 | { | |
381 | int i; | |
382 | memcpy(lsd->lsd_uuid, buf->lsd_uuid, sizeof(lsd->lsd_uuid)); | |
383 | lsd->lsd_last_transno = le64_to_cpu(buf->lsd_last_transno); | |
384 | lsd->lsd_compat14 = le64_to_cpu(buf->lsd_compat14); | |
385 | lsd->lsd_mount_count = le64_to_cpu(buf->lsd_mount_count); | |
386 | lsd->lsd_feature_compat = le32_to_cpu(buf->lsd_feature_compat); | |
387 | lsd->lsd_feature_rocompat = le32_to_cpu(buf->lsd_feature_rocompat); | |
388 | lsd->lsd_feature_incompat = le32_to_cpu(buf->lsd_feature_incompat); | |
389 | lsd->lsd_server_size = le32_to_cpu(buf->lsd_server_size); | |
390 | lsd->lsd_client_start = le32_to_cpu(buf->lsd_client_start); | |
391 | lsd->lsd_client_size = le16_to_cpu(buf->lsd_client_size); | |
392 | lsd->lsd_subdir_count = le16_to_cpu(buf->lsd_subdir_count); | |
393 | lsd->lsd_catalog_oid = le64_to_cpu(buf->lsd_catalog_oid); | |
394 | lsd->lsd_catalog_ogen = le32_to_cpu(buf->lsd_catalog_ogen); | |
395 | memcpy(lsd->lsd_peeruuid, buf->lsd_peeruuid, sizeof(lsd->lsd_peeruuid)); | |
396 | lsd->lsd_osd_index = le32_to_cpu(buf->lsd_osd_index); | |
397 | lsd->lsd_padding1 = le32_to_cpu(buf->lsd_padding1); | |
398 | lsd->lsd_start_epoch = le32_to_cpu(buf->lsd_start_epoch); | |
399 | for (i = 0; i < LR_EXPIRE_INTERVALS; i++) | |
400 | lsd->lsd_trans_table[i] = le64_to_cpu(buf->lsd_trans_table[i]); | |
401 | lsd->lsd_trans_table_time = le32_to_cpu(buf->lsd_trans_table_time); | |
402 | lsd->lsd_expire_intervals = le32_to_cpu(buf->lsd_expire_intervals); | |
403 | } | |
404 | ||
405 | static inline void lsd_cpu_to_le(struct lr_server_data *lsd, | |
406 | struct lr_server_data *buf) | |
407 | { | |
408 | int i; | |
409 | memcpy(buf->lsd_uuid, lsd->lsd_uuid, sizeof(buf->lsd_uuid)); | |
410 | buf->lsd_last_transno = cpu_to_le64(lsd->lsd_last_transno); | |
411 | buf->lsd_compat14 = cpu_to_le64(lsd->lsd_compat14); | |
412 | buf->lsd_mount_count = cpu_to_le64(lsd->lsd_mount_count); | |
413 | buf->lsd_feature_compat = cpu_to_le32(lsd->lsd_feature_compat); | |
414 | buf->lsd_feature_rocompat = cpu_to_le32(lsd->lsd_feature_rocompat); | |
415 | buf->lsd_feature_incompat = cpu_to_le32(lsd->lsd_feature_incompat); | |
416 | buf->lsd_server_size = cpu_to_le32(lsd->lsd_server_size); | |
417 | buf->lsd_client_start = cpu_to_le32(lsd->lsd_client_start); | |
418 | buf->lsd_client_size = cpu_to_le16(lsd->lsd_client_size); | |
419 | buf->lsd_subdir_count = cpu_to_le16(lsd->lsd_subdir_count); | |
420 | buf->lsd_catalog_oid = cpu_to_le64(lsd->lsd_catalog_oid); | |
421 | buf->lsd_catalog_ogen = cpu_to_le32(lsd->lsd_catalog_ogen); | |
422 | memcpy(buf->lsd_peeruuid, lsd->lsd_peeruuid, sizeof(buf->lsd_peeruuid)); | |
423 | buf->lsd_osd_index = cpu_to_le32(lsd->lsd_osd_index); | |
424 | buf->lsd_padding1 = cpu_to_le32(lsd->lsd_padding1); | |
425 | buf->lsd_start_epoch = cpu_to_le32(lsd->lsd_start_epoch); | |
426 | for (i = 0; i < LR_EXPIRE_INTERVALS; i++) | |
427 | buf->lsd_trans_table[i] = cpu_to_le64(lsd->lsd_trans_table[i]); | |
428 | buf->lsd_trans_table_time = cpu_to_le32(lsd->lsd_trans_table_time); | |
429 | buf->lsd_expire_intervals = cpu_to_le32(lsd->lsd_expire_intervals); | |
430 | } | |
431 | ||
432 | static inline void lcd_le_to_cpu(struct lsd_client_data *buf, | |
433 | struct lsd_client_data *lcd) | |
434 | { | |
435 | memcpy(lcd->lcd_uuid, buf->lcd_uuid, sizeof (lcd->lcd_uuid)); | |
436 | lcd->lcd_last_transno = le64_to_cpu(buf->lcd_last_transno); | |
437 | lcd->lcd_last_xid = le64_to_cpu(buf->lcd_last_xid); | |
438 | lcd->lcd_last_result = le32_to_cpu(buf->lcd_last_result); | |
439 | lcd->lcd_last_data = le32_to_cpu(buf->lcd_last_data); | |
440 | lcd->lcd_last_close_transno = le64_to_cpu(buf->lcd_last_close_transno); | |
441 | lcd->lcd_last_close_xid = le64_to_cpu(buf->lcd_last_close_xid); | |
442 | lcd->lcd_last_close_result = le32_to_cpu(buf->lcd_last_close_result); | |
443 | lcd->lcd_last_close_data = le32_to_cpu(buf->lcd_last_close_data); | |
444 | lcd->lcd_pre_versions[0] = le64_to_cpu(buf->lcd_pre_versions[0]); | |
445 | lcd->lcd_pre_versions[1] = le64_to_cpu(buf->lcd_pre_versions[1]); | |
446 | lcd->lcd_pre_versions[2] = le64_to_cpu(buf->lcd_pre_versions[2]); | |
447 | lcd->lcd_pre_versions[3] = le64_to_cpu(buf->lcd_pre_versions[3]); | |
448 | lcd->lcd_last_epoch = le32_to_cpu(buf->lcd_last_epoch); | |
449 | lcd->lcd_first_epoch = le32_to_cpu(buf->lcd_first_epoch); | |
450 | } | |
451 | ||
452 | static inline void lcd_cpu_to_le(struct lsd_client_data *lcd, | |
453 | struct lsd_client_data *buf) | |
454 | { | |
455 | memcpy(buf->lcd_uuid, lcd->lcd_uuid, sizeof (lcd->lcd_uuid)); | |
456 | buf->lcd_last_transno = cpu_to_le64(lcd->lcd_last_transno); | |
457 | buf->lcd_last_xid = cpu_to_le64(lcd->lcd_last_xid); | |
458 | buf->lcd_last_result = cpu_to_le32(lcd->lcd_last_result); | |
459 | buf->lcd_last_data = cpu_to_le32(lcd->lcd_last_data); | |
460 | buf->lcd_last_close_transno = cpu_to_le64(lcd->lcd_last_close_transno); | |
461 | buf->lcd_last_close_xid = cpu_to_le64(lcd->lcd_last_close_xid); | |
462 | buf->lcd_last_close_result = cpu_to_le32(lcd->lcd_last_close_result); | |
463 | buf->lcd_last_close_data = cpu_to_le32(lcd->lcd_last_close_data); | |
464 | buf->lcd_pre_versions[0] = cpu_to_le64(lcd->lcd_pre_versions[0]); | |
465 | buf->lcd_pre_versions[1] = cpu_to_le64(lcd->lcd_pre_versions[1]); | |
466 | buf->lcd_pre_versions[2] = cpu_to_le64(lcd->lcd_pre_versions[2]); | |
467 | buf->lcd_pre_versions[3] = cpu_to_le64(lcd->lcd_pre_versions[3]); | |
468 | buf->lcd_last_epoch = cpu_to_le32(lcd->lcd_last_epoch); | |
469 | buf->lcd_first_epoch = cpu_to_le32(lcd->lcd_first_epoch); | |
470 | } | |
471 | ||
472 | static inline __u64 lcd_last_transno(struct lsd_client_data *lcd) | |
473 | { | |
474 | return (lcd->lcd_last_transno > lcd->lcd_last_close_transno ? | |
475 | lcd->lcd_last_transno : lcd->lcd_last_close_transno); | |
476 | } | |
477 | ||
478 | static inline __u64 lcd_last_xid(struct lsd_client_data *lcd) | |
479 | { | |
480 | return (lcd->lcd_last_xid > lcd->lcd_last_close_xid ? | |
481 | lcd->lcd_last_xid : lcd->lcd_last_close_xid); | |
482 | } | |
483 | ||
484 | /****************** superblock additional info *********************/ | |
485 | ||
486 | struct ll_sb_info; | |
487 | ||
488 | struct lustre_sb_info { | |
489 | int lsi_flags; | |
490 | struct obd_device *lsi_mgc; /* mgc obd */ | |
491 | struct lustre_mount_data *lsi_lmd; /* mount command info */ | |
492 | struct ll_sb_info *lsi_llsbi; /* add'l client sbi info */ | |
493 | struct dt_device *lsi_dt_dev; /* dt device to access disk fs*/ | |
494 | struct vfsmount *lsi_srv_mnt; /* the one server mount */ | |
495 | atomic_t lsi_mounts; /* references to the srv_mnt */ | |
496 | char lsi_svname[MTI_NAME_MAXLEN]; | |
497 | char lsi_osd_obdname[64]; | |
498 | char lsi_osd_uuid[64]; | |
499 | struct obd_export *lsi_osd_exp; | |
500 | char lsi_osd_type[16]; | |
501 | char lsi_fstype[16]; | |
502 | struct backing_dev_info lsi_bdi; /* each client mountpoint needs | |
503 | own backing_dev_info */ | |
504 | }; | |
505 | ||
506 | #define LSI_UMOUNT_FAILOVER 0x00200000 | |
507 | #define LSI_BDI_INITIALIZED 0x00400000 | |
508 | ||
509 | #define s2lsi(sb) ((struct lustre_sb_info *)((sb)->s_fs_info)) | |
510 | #define s2lsi_nocast(sb) ((sb)->s_fs_info) | |
511 | ||
512 | #define get_profile_name(sb) (s2lsi(sb)->lsi_lmd->lmd_profile) | |
513 | #define get_mount_flags(sb) (s2lsi(sb)->lsi_lmd->lmd_flags) | |
514 | #define get_mntdev_name(sb) (s2lsi(sb)->lsi_lmd->lmd_dev) | |
515 | ||
516 | ||
517 | /****************** mount lookup info *********************/ | |
518 | ||
519 | struct lustre_mount_info { | |
520 | char *lmi_name; | |
521 | struct super_block *lmi_sb; | |
522 | struct vfsmount *lmi_mnt; | |
523 | struct list_head lmi_list_chain; | |
524 | }; | |
525 | ||
d7e09d03 PT |
526 | /****************** prototypes *********************/ |
527 | ||
528 | /* obd_mount.c */ | |
529 | int server_name2fsname(const char *svname, char *fsname, const char **endptr); | |
530 | int server_name2index(const char *svname, __u32 *idx, const char **endptr); | |
531 | int server_name2svname(const char *label, char *svname, const char **endptr, | |
532 | size_t svsize); | |
533 | ||
534 | int lustre_put_lsi(struct super_block *sb); | |
535 | int lustre_start_simple(char *obdname, char *type, char *uuid, | |
536 | char *s1, char *s2, char *s3, char *s4); | |
537 | int lustre_start_mgc(struct super_block *sb); | |
538 | void lustre_register_client_fill_super(int (*cfs)(struct super_block *sb, | |
539 | struct vfsmount *mnt)); | |
540 | void lustre_register_kill_super_cb(void (*cfs)(struct super_block *sb)); | |
541 | int lustre_common_put_super(struct super_block *sb); | |
542 | ||
543 | ||
544 | int mgc_fsname2resid(char *fsname, struct ldlm_res_id *res_id, int type); | |
545 | ||
546 | /** @} disk */ | |
547 | ||
995c8b4a | 548 | #endif /* _LUSTRE_DISK_H */ |