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) 2003, 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 | * lustre/include/lustre/lustre_user.h | |
37 | * | |
38 | * Lustre public user-space interface definitions. | |
39 | */ | |
40 | ||
41 | #ifndef _LUSTRE_USER_H | |
42 | #define _LUSTRE_USER_H | |
43 | ||
44 | /** \defgroup lustreuser lustreuser | |
45 | * | |
46 | * @{ | |
47 | */ | |
48 | ||
49 | #include <lustre/ll_fiemap.h> | |
50 | #include <linux/lustre_user.h> | |
51 | ||
52 | /* for statfs() */ | |
53 | #define LL_SUPER_MAGIC 0x0BD00BD0 | |
54 | ||
55 | #ifndef FSFILT_IOC_GETFLAGS | |
56 | #define FSFILT_IOC_GETFLAGS _IOR('f', 1, long) | |
57 | #define FSFILT_IOC_SETFLAGS _IOW('f', 2, long) | |
58 | #define FSFILT_IOC_GETVERSION _IOR('f', 3, long) | |
59 | #define FSFILT_IOC_SETVERSION _IOW('f', 4, long) | |
60 | #define FSFILT_IOC_GETVERSION_OLD _IOR('v', 1, long) | |
61 | #define FSFILT_IOC_SETVERSION_OLD _IOW('v', 2, long) | |
62 | #define FSFILT_IOC_FIEMAP _IOWR('f', 11, struct ll_user_fiemap) | |
63 | #endif | |
64 | ||
65 | /* FIEMAP flags supported by Lustre */ | |
66 | #define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER) | |
67 | ||
68 | enum obd_statfs_state { | |
69 | OS_STATE_DEGRADED = 0x00000001, /**< RAID degraded/rebuilding */ | |
70 | OS_STATE_READONLY = 0x00000002, /**< filesystem is read-only */ | |
71 | OS_STATE_RDONLY_1 = 0x00000004, /**< obsolete 1.6, was EROFS=30 */ | |
72 | OS_STATE_RDONLY_2 = 0x00000008, /**< obsolete 1.6, was EROFS=30 */ | |
73 | OS_STATE_RDONLY_3 = 0x00000010, /**< obsolete 1.6, was EROFS=30 */ | |
74 | }; | |
75 | ||
76 | struct obd_statfs { | |
77 | __u64 os_type; | |
78 | __u64 os_blocks; | |
79 | __u64 os_bfree; | |
80 | __u64 os_bavail; | |
81 | __u64 os_files; | |
82 | __u64 os_ffree; | |
83 | __u8 os_fsid[40]; | |
84 | __u32 os_bsize; | |
85 | __u32 os_namelen; | |
86 | __u64 os_maxbytes; | |
87 | __u32 os_state; /**< obd_statfs_state OS_STATE_* flag */ | |
88 | __u32 os_fprecreated; /* objs available now to the caller */ | |
89 | /* used in QoS code to find preferred | |
90 | * OSTs */ | |
91 | __u32 os_spare2; | |
92 | __u32 os_spare3; | |
93 | __u32 os_spare4; | |
94 | __u32 os_spare5; | |
95 | __u32 os_spare6; | |
96 | __u32 os_spare7; | |
97 | __u32 os_spare8; | |
98 | __u32 os_spare9; | |
99 | }; | |
100 | ||
101 | /** | |
102 | * File IDentifier. | |
103 | * | |
104 | * FID is a cluster-wide unique identifier of a file or an object (stripe). | |
105 | * FIDs are never reused. | |
106 | **/ | |
107 | struct lu_fid { | |
108 | /** | |
109 | * FID sequence. Sequence is a unit of migration: all files (objects) | |
110 | * with FIDs from a given sequence are stored on the same server. | |
111 | * Lustre should support 2^64 objects, so even if each sequence | |
112 | * has only a single object we can still enumerate 2^64 objects. | |
113 | **/ | |
114 | __u64 f_seq; | |
115 | /* FID number within sequence. */ | |
116 | __u32 f_oid; | |
117 | /** | |
118 | * FID version, used to distinguish different versions (in the sense | |
119 | * of snapshots, etc.) of the same file system object. Not currently | |
120 | * used. | |
121 | **/ | |
122 | __u32 f_ver; | |
123 | }; | |
124 | ||
125 | struct filter_fid { | |
126 | struct lu_fid ff_parent; /* ff_parent.f_ver == file stripe number */ | |
127 | }; | |
128 | ||
129 | /* keep this one for compatibility */ | |
130 | struct filter_fid_old { | |
131 | struct lu_fid ff_parent; | |
132 | __u64 ff_objid; | |
133 | __u64 ff_seq; | |
134 | }; | |
135 | ||
136 | /* Userspace should treat lu_fid as opaque, and only use the following methods | |
137 | * to print or parse them. Other functions (e.g. compare, swab) could be moved | |
138 | * here from lustre_idl.h if needed. */ | |
139 | typedef struct lu_fid lustre_fid; | |
140 | ||
141 | /** | |
142 | * Following struct for object attributes, that will be kept inode's EA. | |
143 | * Introduced in 2.0 release (please see b15993, for details) | |
144 | * Added to all objects since Lustre 2.4 as contains self FID | |
145 | */ | |
146 | struct lustre_mdt_attrs { | |
147 | /** | |
148 | * Bitfield for supported data in this structure. From enum lma_compat. | |
149 | * lma_self_fid and lma_flags are always available. | |
150 | */ | |
151 | __u32 lma_compat; | |
152 | /** | |
153 | * Per-file incompat feature list. Lustre version should support all | |
154 | * flags set in this field. The supported feature mask is available in | |
155 | * LMA_INCOMPAT_SUPP. | |
156 | */ | |
157 | __u32 lma_incompat; | |
158 | /** FID of this inode */ | |
159 | struct lu_fid lma_self_fid; | |
160 | }; | |
161 | ||
162 | /** | |
163 | * Prior to 2.4, the LMA structure also included SOM attributes which has since | |
164 | * been moved to a dedicated xattr | |
165 | * lma_flags was also removed because of lma_compat/incompat fields. | |
166 | */ | |
167 | #define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64)) | |
168 | ||
169 | /** | |
170 | * OST object IDentifier. | |
171 | */ | |
172 | struct ost_id { | |
173 | union { | |
174 | struct ostid { | |
175 | __u64 oi_id; | |
176 | __u64 oi_seq; | |
177 | } oi; | |
178 | struct lu_fid oi_fid; | |
179 | }; | |
180 | }; | |
181 | ||
182 | #define DOSTID LPX64":"LPU64 | |
183 | #define POSTID(oi) ostid_seq(oi), ostid_id(oi) | |
184 | ||
185 | /* | |
186 | * The ioctl naming rules: | |
187 | * LL_* - works on the currently opened filehandle instead of parent dir | |
188 | * *_OBD_* - gets data for both OSC or MDC (LOV, LMV indirectly) | |
189 | * *_MDC_* - gets/sets data related to MDC | |
190 | * *_LOV_* - gets/sets data related to OSC/LOV | |
191 | * *FILE* - called on parent dir and passes in a filename | |
192 | * *STRIPE* - set/get lov_user_md | |
193 | * *INFO - set/get lov_user_mds_data | |
194 | */ | |
195 | /* see <lustre_lib.h> for ioctl numberss 101-150 */ | |
196 | #define LL_IOC_GETFLAGS _IOR ('f', 151, long) | |
197 | #define LL_IOC_SETFLAGS _IOW ('f', 152, long) | |
198 | #define LL_IOC_CLRFLAGS _IOW ('f', 153, long) | |
199 | /* LL_IOC_LOV_SETSTRIPE: See also OBD_IOC_LOV_SETSTRIPE */ | |
200 | #define LL_IOC_LOV_SETSTRIPE _IOW ('f', 154, long) | |
201 | /* LL_IOC_LOV_GETSTRIPE: See also OBD_IOC_LOV_GETSTRIPE */ | |
202 | #define LL_IOC_LOV_GETSTRIPE _IOW ('f', 155, long) | |
203 | /* LL_IOC_LOV_SETEA: See also OBD_IOC_LOV_SETEA */ | |
204 | #define LL_IOC_LOV_SETEA _IOW ('f', 156, long) | |
205 | #define LL_IOC_RECREATE_OBJ _IOW ('f', 157, long) | |
206 | #define LL_IOC_RECREATE_FID _IOW ('f', 157, struct lu_fid) | |
207 | #define LL_IOC_GROUP_LOCK _IOW ('f', 158, long) | |
208 | #define LL_IOC_GROUP_UNLOCK _IOW ('f', 159, long) | |
209 | /* LL_IOC_QUOTACHECK: See also OBD_IOC_QUOTACHECK */ | |
210 | #define LL_IOC_QUOTACHECK _IOW ('f', 160, int) | |
211 | /* LL_IOC_POLL_QUOTACHECK: See also OBD_IOC_POLL_QUOTACHECK */ | |
212 | #define LL_IOC_POLL_QUOTACHECK _IOR ('f', 161, struct if_quotacheck *) | |
213 | /* LL_IOC_QUOTACTL: See also OBD_IOC_QUOTACTL */ | |
214 | #define LL_IOC_QUOTACTL _IOWR('f', 162, struct if_quotactl) | |
215 | #define IOC_OBD_STATFS _IOWR('f', 164, struct obd_statfs *) | |
216 | #define IOC_LOV_GETINFO _IOWR('f', 165, struct lov_user_mds_data *) | |
217 | #define LL_IOC_FLUSHCTX _IOW ('f', 166, long) | |
218 | #define LL_IOC_RMTACL _IOW ('f', 167, long) | |
219 | #define LL_IOC_GETOBDCOUNT _IOR ('f', 168, long) | |
220 | #define LL_IOC_LLOOP_ATTACH _IOWR('f', 169, long) | |
221 | #define LL_IOC_LLOOP_DETACH _IOWR('f', 170, long) | |
222 | #define LL_IOC_LLOOP_INFO _IOWR('f', 171, struct lu_fid) | |
223 | #define LL_IOC_LLOOP_DETACH_BYDEV _IOWR('f', 172, long) | |
224 | #define LL_IOC_PATH2FID _IOR ('f', 173, long) | |
225 | #define LL_IOC_GET_CONNECT_FLAGS _IOWR('f', 174, __u64 *) | |
226 | #define LL_IOC_GET_MDTIDX _IOR ('f', 175, int) | |
227 | ||
228 | /* see <lustre_lib.h> for ioctl numbers 177-210 */ | |
229 | ||
230 | #define LL_IOC_HSM_STATE_GET _IOR('f', 211, struct hsm_user_state) | |
231 | #define LL_IOC_HSM_STATE_SET _IOW('f', 212, struct hsm_state_set) | |
232 | #define LL_IOC_HSM_CT_START _IOW('f', 213, struct lustre_kernelcomm) | |
233 | #define LL_IOC_HSM_COPY_START _IOW('f', 214, struct hsm_copy *) | |
234 | #define LL_IOC_HSM_COPY_END _IOW('f', 215, struct hsm_copy *) | |
235 | #define LL_IOC_HSM_PROGRESS _IOW('f', 216, struct hsm_user_request) | |
236 | #define LL_IOC_HSM_REQUEST _IOW('f', 217, struct hsm_user_request) | |
237 | #define LL_IOC_DATA_VERSION _IOR('f', 218, struct ioc_data_version) | |
238 | #define LL_IOC_LOV_SWAP_LAYOUTS _IOW('f', 219, \ | |
239 | struct lustre_swap_layouts) | |
240 | #define LL_IOC_HSM_ACTION _IOR('f', 220, \ | |
241 | struct hsm_current_action) | |
242 | /* see <lustre_lib.h> for ioctl numbers 221-232 */ | |
243 | ||
244 | #define LL_IOC_LMV_SETSTRIPE _IOWR('f', 240, struct lmv_user_md) | |
245 | #define LL_IOC_LMV_GETSTRIPE _IOWR('f', 241, struct lmv_user_md) | |
246 | #define LL_IOC_REMOVE_ENTRY _IOWR('f', 242, __u64) | |
d3a8a4e2 JX |
247 | #define LL_IOC_SET_LEASE _IOWR('f', 243, long) |
248 | #define LL_IOC_GET_LEASE _IO('f', 244) | |
a720b790 | 249 | #define LL_IOC_HSM_IMPORT _IOWR('f', 245, struct hsm_user_import) |
d3a8a4e2 | 250 | |
d7e09d03 PT |
251 | #define LL_STATFS_LMV 1 |
252 | #define LL_STATFS_LOV 2 | |
253 | #define LL_STATFS_NODELAY 4 | |
254 | ||
255 | #define IOC_MDC_TYPE 'i' | |
256 | #define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *) | |
257 | #define IOC_MDC_GETFILESTRIPE _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *) | |
258 | #define IOC_MDC_GETFILEINFO _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data *) | |
259 | #define LL_IOC_MDC_GETINFO _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data *) | |
260 | ||
261 | /* Keep these for backward compartability. */ | |
262 | #define LL_IOC_OBD_STATFS IOC_OBD_STATFS | |
263 | #define IOC_MDC_GETSTRIPE IOC_MDC_GETFILESTRIPE | |
264 | ||
265 | ||
266 | #define MAX_OBD_NAME 128 /* If this changes, a NEW ioctl must be added */ | |
267 | ||
268 | /* Hopefully O_LOV_DELAY_CREATE does not conflict with standard O_xxx flags. | |
269 | * Previously it was defined as 0100000000 and conflicts with FMODE_NONOTIFY | |
270 | * which was added since kernel 2.6.36, so we redefine it as 020000000. | |
271 | * To be compatible with old version's statically linked binary, finally we | |
272 | * define it as (020000000 | 0100000000). | |
273 | * */ | |
274 | #define O_LOV_DELAY_CREATE 0120000000 | |
275 | ||
276 | #define LL_FILE_IGNORE_LOCK 0x00000001 | |
277 | #define LL_FILE_GROUP_LOCKED 0x00000002 | |
278 | #define LL_FILE_READAHEA 0x00000004 | |
279 | #define LL_FILE_LOCKED_DIRECTIO 0x00000008 /* client-side locks with dio */ | |
280 | #define LL_FILE_LOCKLESS_IO 0x00000010 /* server-side locks with cio */ | |
281 | #define LL_FILE_RMTACL 0x00000020 | |
282 | ||
283 | #define LOV_USER_MAGIC_V1 0x0BD10BD0 | |
284 | #define LOV_USER_MAGIC LOV_USER_MAGIC_V1 | |
285 | #define LOV_USER_MAGIC_JOIN_V1 0x0BD20BD0 | |
286 | #define LOV_USER_MAGIC_V3 0x0BD30BD0 | |
287 | ||
288 | #define LMV_MAGIC_V1 0x0CD10CD0 /*normal stripe lmv magic */ | |
289 | #define LMV_USER_MAGIC 0x0CD20CD0 /*default lmv magic*/ | |
290 | ||
291 | #define LOV_PATTERN_RAID0 0x001 | |
292 | #define LOV_PATTERN_RAID1 0x002 | |
293 | #define LOV_PATTERN_FIRST 0x100 | |
294 | ||
295 | #define LOV_MAXPOOLNAME 16 | |
296 | #define LOV_POOLNAMEF "%.16s" | |
297 | ||
298 | #define LOV_MIN_STRIPE_BITS 16 /* maximum PAGE_SIZE (ia64), power of 2 */ | |
299 | #define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS) | |
300 | #define LOV_MAX_STRIPE_COUNT_OLD 160 | |
301 | /* This calculation is crafted so that input of 4096 will result in 160 | |
302 | * which in turn is equal to old maximal stripe count. | |
303 | * XXX: In fact this is too simpified for now, what it also need is to get | |
304 | * ea_type argument to clearly know how much space each stripe consumes. | |
305 | * | |
306 | * The limit of 12 pages is somewhat arbitrary, but is a reasonably large | |
307 | * allocation that is sufficient for the current generation of systems. | |
308 | * | |
309 | * (max buffer size - lov+rpc header) / sizeof(struct lov_ost_data_v1) */ | |
310 | #define LOV_MAX_STRIPE_COUNT 2000 /* ((12 * 4096 - 256) / 24) */ | |
311 | #define LOV_ALL_STRIPES 0xffff /* only valid for directories */ | |
312 | #define LOV_V1_INSANE_STRIPE_COUNT 65532 /* maximum stripe count bz13933 */ | |
313 | ||
314 | #define lov_user_ost_data lov_user_ost_data_v1 | |
315 | struct lov_user_ost_data_v1 { /* per-stripe data structure */ | |
316 | struct ost_id l_ost_oi; /* OST object ID */ | |
317 | __u32 l_ost_gen; /* generation of this OST index */ | |
318 | __u32 l_ost_idx; /* OST index in LOV */ | |
319 | } __attribute__((packed)); | |
320 | ||
321 | #define lov_user_md lov_user_md_v1 | |
322 | struct lov_user_md_v1 { /* LOV EA user data (host-endian) */ | |
323 | __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V1 */ | |
324 | __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */ | |
325 | struct ost_id lmm_oi; /* LOV object ID */ | |
326 | __u32 lmm_stripe_size; /* size of stripe in bytes */ | |
327 | __u16 lmm_stripe_count; /* num stripes in use for this object */ | |
328 | union { | |
329 | __u16 lmm_stripe_offset; /* starting stripe offset in | |
330 | * lmm_objects, use when writing */ | |
331 | __u16 lmm_layout_gen; /* layout generation number | |
332 | * used when reading */ | |
333 | }; | |
334 | struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */ | |
335 | } __attribute__((packed, __may_alias__)); | |
336 | ||
337 | struct lov_user_md_v3 { /* LOV EA user data (host-endian) */ | |
338 | __u32 lmm_magic; /* magic number = LOV_USER_MAGIC_V3 */ | |
339 | __u32 lmm_pattern; /* LOV_PATTERN_RAID0, LOV_PATTERN_RAID1 */ | |
340 | struct ost_id lmm_oi; /* LOV object ID */ | |
341 | __u32 lmm_stripe_size; /* size of stripe in bytes */ | |
342 | __u16 lmm_stripe_count; /* num stripes in use for this object */ | |
343 | union { | |
344 | __u16 lmm_stripe_offset; /* starting stripe offset in | |
345 | * lmm_objects, use when writing */ | |
346 | __u16 lmm_layout_gen; /* layout generation number | |
347 | * used when reading */ | |
348 | }; | |
349 | char lmm_pool_name[LOV_MAXPOOLNAME]; /* pool name */ | |
350 | struct lov_user_ost_data_v1 lmm_objects[0]; /* per-stripe data */ | |
351 | } __attribute__((packed)); | |
352 | ||
bc06a678 | 353 | static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic) |
354 | { | |
355 | if (lmm_magic == LOV_USER_MAGIC_V3) | |
356 | return sizeof(struct lov_user_md_v3) + | |
357 | stripes * sizeof(struct lov_user_ost_data_v1); | |
358 | else | |
359 | return sizeof(struct lov_user_md_v1) + | |
360 | stripes * sizeof(struct lov_user_ost_data_v1); | |
361 | } | |
362 | ||
d7e09d03 PT |
363 | /* Compile with -D_LARGEFILE64_SOURCE or -D_GNU_SOURCE (or #define) to |
364 | * use this. It is unsafe to #define those values in this header as it | |
365 | * is possible the application has already #included <sys/stat.h>. */ | |
366 | #ifdef HAVE_LOV_USER_MDS_DATA | |
367 | #define lov_user_mds_data lov_user_mds_data_v1 | |
368 | struct lov_user_mds_data_v1 { | |
369 | lstat_t lmd_st; /* MDS stat struct */ | |
370 | struct lov_user_md_v1 lmd_lmm; /* LOV EA V1 user data */ | |
371 | } __attribute__((packed)); | |
372 | ||
373 | struct lov_user_mds_data_v3 { | |
374 | lstat_t lmd_st; /* MDS stat struct */ | |
375 | struct lov_user_md_v3 lmd_lmm; /* LOV EA V3 user data */ | |
376 | } __attribute__((packed)); | |
377 | #endif | |
378 | ||
379 | /* keep this to be the same size as lov_user_ost_data_v1 */ | |
380 | struct lmv_user_mds_data { | |
381 | struct lu_fid lum_fid; | |
382 | __u32 lum_padding; | |
383 | __u32 lum_mds; | |
384 | }; | |
385 | ||
386 | /* lum_type */ | |
387 | enum { | |
388 | LMV_STRIPE_TYPE = 0, | |
389 | LMV_DEFAULT_TYPE = 1, | |
390 | }; | |
391 | ||
392 | #define lmv_user_md lmv_user_md_v1 | |
393 | struct lmv_user_md_v1 { | |
394 | __u32 lum_magic; /* must be the first field */ | |
395 | __u32 lum_stripe_count; /* dirstripe count */ | |
396 | __u32 lum_stripe_offset; /* MDT idx for default dirstripe */ | |
397 | __u32 lum_hash_type; /* Dir stripe policy */ | |
398 | __u32 lum_type; /* LMV type: default or normal */ | |
399 | __u32 lum_padding1; | |
400 | __u32 lum_padding2; | |
401 | __u32 lum_padding3; | |
402 | char lum_pool_name[LOV_MAXPOOLNAME]; | |
403 | struct lmv_user_mds_data lum_objects[0]; | |
404 | }; | |
405 | ||
406 | static inline int lmv_user_md_size(int stripes, int lmm_magic) | |
407 | { | |
408 | return sizeof(struct lmv_user_md) + | |
409 | stripes * sizeof(struct lmv_user_mds_data); | |
410 | } | |
411 | ||
412 | extern void lustre_swab_lmv_user_md(struct lmv_user_md *lum); | |
413 | ||
414 | struct ll_recreate_obj { | |
415 | __u64 lrc_id; | |
416 | __u32 lrc_ost_idx; | |
417 | }; | |
418 | ||
419 | struct ll_fid { | |
420 | __u64 id; /* holds object id */ | |
421 | __u32 generation; /* holds object generation */ | |
422 | __u32 f_type; /* holds object type or stripe idx when passing it to | |
423 | * OST for saving into EA. */ | |
424 | }; | |
425 | ||
426 | #define UUID_MAX 40 | |
427 | struct obd_uuid { | |
428 | char uuid[UUID_MAX]; | |
429 | }; | |
430 | ||
211b3168 JL |
431 | static inline bool obd_uuid_equals(const struct obd_uuid *u1, |
432 | const struct obd_uuid *u2) | |
d7e09d03 PT |
433 | { |
434 | return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0; | |
435 | } | |
436 | ||
437 | static inline int obd_uuid_empty(struct obd_uuid *uuid) | |
438 | { | |
439 | return uuid->uuid[0] == '\0'; | |
440 | } | |
441 | ||
442 | static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp) | |
443 | { | |
444 | strncpy((char *)uuid->uuid, tmp, sizeof(*uuid)); | |
445 | uuid->uuid[sizeof(*uuid) - 1] = '\0'; | |
446 | } | |
447 | ||
448 | /* For printf's only, make sure uuid is terminated */ | |
1ecc2061 | 449 | static inline char *obd_uuid2str(const struct obd_uuid *uuid) |
d7e09d03 PT |
450 | { |
451 | if (uuid->uuid[sizeof(*uuid) - 1] != '\0') { | |
452 | /* Obviously not safe, but for printfs, no real harm done... | |
453 | we're always null-terminated, even in a race. */ | |
454 | static char temp[sizeof(*uuid)]; | |
455 | memcpy(temp, uuid->uuid, sizeof(*uuid) - 1); | |
456 | temp[sizeof(*uuid) - 1] = '\0'; | |
457 | return temp; | |
458 | } | |
459 | return (char *)(uuid->uuid); | |
460 | } | |
461 | ||
462 | /* Extract fsname from uuid (or target name) of a target | |
463 | e.g. (myfs-OST0007_UUID -> myfs) | |
464 | see also deuuidify. */ | |
465 | static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen) | |
466 | { | |
467 | char *p; | |
468 | ||
469 | strncpy(buf, uuid, buflen - 1); | |
470 | buf[buflen - 1] = '\0'; | |
471 | p = strrchr(buf, '-'); | |
472 | if (p) | |
473 | *p = '\0'; | |
474 | } | |
475 | ||
476 | /* printf display format | |
477 | e.g. printf("file FID is "DFID"\n", PFID(fid)); */ | |
001f5487 | 478 | #define FID_NOBRACE_LEN 40 |
479 | #define FID_LEN (FID_NOBRACE_LEN + 2) | |
d7e09d03 PT |
480 | #define DFID_NOBRACE LPX64":0x%x:0x%x" |
481 | #define DFID "["DFID_NOBRACE"]" | |
482 | #define PFID(fid) \ | |
483 | (fid)->f_seq, \ | |
484 | (fid)->f_oid, \ | |
485 | (fid)->f_ver | |
486 | ||
487 | /* scanf input parse format -- strip '[' first. | |
488 | e.g. sscanf(fidstr, SFID, RFID(&fid)); */ | |
489 | /* #define SFID "0x"LPX64i":0x"LPSZX":0x"LPSZX"" | |
490 | liblustreapi.c:2893: warning: format '%lx' expects type 'long unsigned int *', but argument 4 has type 'unsigned int *' | |
491 | liblustreapi.c:2893: warning: format '%lx' expects type 'long unsigned int *', but argument 5 has type 'unsigned int *' | |
492 | */ | |
493 | #define SFID "0x"LPX64i":0x%x:0x%x" | |
494 | #define RFID(fid) \ | |
495 | &((fid)->f_seq), \ | |
496 | &((fid)->f_oid), \ | |
497 | &((fid)->f_ver) | |
498 | ||
499 | ||
500 | /********* Quotas **********/ | |
501 | ||
502 | /* these must be explicitly translated into linux Q_* in ll_dir_ioctl */ | |
503 | #define LUSTRE_Q_QUOTAON 0x800002 /* turn quotas on */ | |
504 | #define LUSTRE_Q_QUOTAOFF 0x800003 /* turn quotas off */ | |
505 | #define LUSTRE_Q_GETINFO 0x800005 /* get information about quota files */ | |
506 | #define LUSTRE_Q_SETINFO 0x800006 /* set information about quota files */ | |
507 | #define LUSTRE_Q_GETQUOTA 0x800007 /* get user quota structure */ | |
508 | #define LUSTRE_Q_SETQUOTA 0x800008 /* set user quota structure */ | |
509 | /* lustre-specific control commands */ | |
510 | #define LUSTRE_Q_INVALIDATE 0x80000b /* invalidate quota data */ | |
511 | #define LUSTRE_Q_FINVALIDATE 0x80000c /* invalidate filter quota data */ | |
512 | ||
513 | #define UGQUOTA 2 /* set both USRQUOTA and GRPQUOTA */ | |
514 | ||
515 | struct if_quotacheck { | |
516 | char obd_type[16]; | |
517 | struct obd_uuid obd_uuid; | |
518 | }; | |
519 | ||
520 | #define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629 | |
521 | ||
522 | /* permission */ | |
523 | #define N_PERMS_MAX 64 | |
524 | ||
525 | struct perm_downcall_data { | |
526 | __u64 pdd_nid; | |
527 | __u32 pdd_perm; | |
528 | __u32 pdd_padding; | |
529 | }; | |
530 | ||
531 | struct identity_downcall_data { | |
532 | __u32 idd_magic; | |
533 | __u32 idd_err; | |
534 | __u32 idd_uid; | |
535 | __u32 idd_gid; | |
536 | __u32 idd_nperms; | |
537 | __u32 idd_ngroups; | |
538 | struct perm_downcall_data idd_perms[N_PERMS_MAX]; | |
539 | __u32 idd_groups[0]; | |
540 | }; | |
541 | ||
542 | /* for non-mapped uid/gid */ | |
543 | #define NOBODY_UID 99 | |
544 | #define NOBODY_GID 99 | |
545 | ||
546 | #define INVALID_ID (-1) | |
547 | ||
548 | enum { | |
549 | RMT_LSETFACL = 1, | |
550 | RMT_LGETFACL = 2, | |
551 | RMT_RSETFACL = 3, | |
552 | RMT_RGETFACL = 4 | |
553 | }; | |
554 | ||
555 | #ifdef NEED_QUOTA_DEFS | |
556 | #ifndef QIF_BLIMITS | |
557 | #define QIF_BLIMITS 1 | |
558 | #define QIF_SPACE 2 | |
559 | #define QIF_ILIMITS 4 | |
560 | #define QIF_INODES 8 | |
561 | #define QIF_BTIME 16 | |
562 | #define QIF_ITIME 32 | |
563 | #define QIF_LIMITS (QIF_BLIMITS | QIF_ILIMITS) | |
564 | #define QIF_USAGE (QIF_SPACE | QIF_INODES) | |
565 | #define QIF_TIMES (QIF_BTIME | QIF_ITIME) | |
566 | #define QIF_ALL (QIF_LIMITS | QIF_USAGE | QIF_TIMES) | |
567 | #endif | |
568 | ||
569 | #endif /* !__KERNEL__ */ | |
570 | ||
571 | /* lustre volatile file support | |
572 | * file name header: .^L^S^T^R:volatile" | |
573 | */ | |
574 | #define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE" | |
575 | #define LUSTRE_VOLATILE_HDR_LEN 14 | |
576 | /* hdr + MDT index */ | |
577 | #define LUSTRE_VOLATILE_IDX LUSTRE_VOLATILE_HDR":%.4X:" | |
578 | ||
579 | typedef enum lustre_quota_version { | |
580 | LUSTRE_QUOTA_V2 = 1 | |
581 | } lustre_quota_version_t; | |
582 | ||
583 | /* XXX: same as if_dqinfo struct in kernel */ | |
584 | struct obd_dqinfo { | |
585 | __u64 dqi_bgrace; | |
586 | __u64 dqi_igrace; | |
587 | __u32 dqi_flags; | |
588 | __u32 dqi_valid; | |
589 | }; | |
590 | ||
591 | /* XXX: same as if_dqblk struct in kernel, plus one padding */ | |
592 | struct obd_dqblk { | |
593 | __u64 dqb_bhardlimit; | |
594 | __u64 dqb_bsoftlimit; | |
595 | __u64 dqb_curspace; | |
596 | __u64 dqb_ihardlimit; | |
597 | __u64 dqb_isoftlimit; | |
598 | __u64 dqb_curinodes; | |
599 | __u64 dqb_btime; | |
600 | __u64 dqb_itime; | |
601 | __u32 dqb_valid; | |
602 | __u32 dqb_padding; | |
603 | }; | |
604 | ||
605 | enum { | |
606 | QC_GENERAL = 0, | |
607 | QC_MDTIDX = 1, | |
608 | QC_OSTIDX = 2, | |
609 | QC_UUID = 3 | |
610 | }; | |
611 | ||
612 | struct if_quotactl { | |
613 | __u32 qc_cmd; | |
614 | __u32 qc_type; | |
615 | __u32 qc_id; | |
616 | __u32 qc_stat; | |
617 | __u32 qc_valid; | |
618 | __u32 qc_idx; | |
619 | struct obd_dqinfo qc_dqinfo; | |
620 | struct obd_dqblk qc_dqblk; | |
621 | char obd_type[16]; | |
622 | struct obd_uuid obd_uuid; | |
623 | }; | |
624 | ||
625 | /* swap layout flags */ | |
48d23e61 JX |
626 | #define SWAP_LAYOUTS_CHECK_DV1 (1 << 0) |
627 | #define SWAP_LAYOUTS_CHECK_DV2 (1 << 1) | |
628 | #define SWAP_LAYOUTS_KEEP_MTIME (1 << 2) | |
629 | #define SWAP_LAYOUTS_KEEP_ATIME (1 << 3) | |
630 | ||
631 | /* Swap XATTR_NAME_HSM as well, only on the MDT so far */ | |
632 | #define SWAP_LAYOUTS_MDS_HSM (1 << 31) | |
d7e09d03 PT |
633 | struct lustre_swap_layouts { |
634 | __u64 sl_flags; | |
635 | __u32 sl_fd; | |
636 | __u32 sl_gid; | |
637 | __u64 sl_dv1; | |
638 | __u64 sl_dv2; | |
639 | }; | |
640 | ||
641 | ||
642 | /********* Changelogs **********/ | |
643 | /** Changelog record types */ | |
644 | enum changelog_rec_type { | |
645 | CL_MARK = 0, | |
646 | CL_CREATE = 1, /* namespace */ | |
647 | CL_MKDIR = 2, /* namespace */ | |
648 | CL_HARDLINK = 3, /* namespace */ | |
649 | CL_SOFTLINK = 4, /* namespace */ | |
650 | CL_MKNOD = 5, /* namespace */ | |
651 | CL_UNLINK = 6, /* namespace */ | |
652 | CL_RMDIR = 7, /* namespace */ | |
653 | CL_RENAME = 8, /* namespace */ | |
654 | CL_EXT = 9, /* namespace extended record (2nd half of rename) */ | |
655 | CL_OPEN = 10, /* not currently used */ | |
656 | CL_CLOSE = 11, /* may be written to log only with mtime change */ | |
e11b0b16 | 657 | CL_LAYOUT = 12, /* file layout/striping modified */ |
d7e09d03 PT |
658 | CL_TRUNC = 13, |
659 | CL_SETATTR = 14, | |
660 | CL_XATTR = 15, | |
661 | CL_HSM = 16, /* HSM specific events, see flags */ | |
662 | CL_MTIME = 17, /* Precedence: setattr > mtime > ctime > atime */ | |
663 | CL_CTIME = 18, | |
664 | CL_ATIME = 19, | |
d7e09d03 PT |
665 | CL_LAST |
666 | }; | |
667 | ||
668 | static inline const char *changelog_type2str(int type) { | |
669 | static const char *changelog_str[] = { | |
670 | "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK", | |
e11b0b16 | 671 | "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC", |
e377988e | 672 | "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME", |
d7e09d03 PT |
673 | }; |
674 | ||
675 | if (type >= 0 && type < CL_LAST) | |
676 | return changelog_str[type]; | |
677 | return NULL; | |
678 | } | |
679 | ||
680 | /* per-record flags */ | |
681 | #define CLF_VERSION 0x1000 | |
682 | #define CLF_EXT_VERSION 0x2000 | |
683 | #define CLF_FLAGSHIFT 12 | |
684 | #define CLF_FLAGMASK ((1U << CLF_FLAGSHIFT) - 1) | |
685 | #define CLF_VERMASK (~CLF_FLAGMASK) | |
686 | /* Anything under the flagmask may be per-type (if desired) */ | |
687 | /* Flags for unlink */ | |
688 | #define CLF_UNLINK_LAST 0x0001 /* Unlink of last hardlink */ | |
689 | #define CLF_UNLINK_HSM_EXISTS 0x0002 /* File has something in HSM */ | |
690 | /* HSM cleaning needed */ | |
691 | /* Flags for rename */ | |
692 | #define CLF_RENAME_LAST 0x0001 /* rename unlink last hardlink of target */ | |
693 | ||
694 | /* Flags for HSM */ | |
695 | /* 12b used (from high weight to low weight): | |
696 | * 2b for flags | |
697 | * 3b for event | |
698 | * 7b for error code | |
699 | */ | |
700 | #define CLF_HSM_ERR_L 0 /* HSM return code, 7 bits */ | |
701 | #define CLF_HSM_ERR_H 6 | |
702 | #define CLF_HSM_EVENT_L 7 /* HSM event, 3 bits, see enum hsm_event */ | |
703 | #define CLF_HSM_EVENT_H 9 | |
704 | #define CLF_HSM_FLAG_L 10 /* HSM flags, 2 bits, 1 used, 1 spare */ | |
705 | #define CLF_HSM_FLAG_H 11 | |
706 | #define CLF_HSM_SPARE_L 12 /* 4 spare bits */ | |
707 | #define CLF_HSM_SPARE_H 15 | |
708 | #define CLF_HSM_LAST 15 | |
709 | ||
710 | /* Remove bits higher than _h, then extract the value | |
711 | * between _h and _l by shifting lower weigth to bit 0. */ | |
712 | #define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \ | |
713 | >> (CLF_HSM_LAST - _h + _l)) | |
714 | ||
715 | #define CLF_HSM_SUCCESS 0x00 | |
716 | #define CLF_HSM_MAXERROR 0x7E | |
717 | #define CLF_HSM_ERROVERFLOW 0x7F | |
718 | ||
719 | #define CLF_HSM_DIRTY 1 /* file is dirty after HSM request end */ | |
720 | ||
721 | /* 3 bits field => 8 values allowed */ | |
722 | enum hsm_event { | |
723 | HE_ARCHIVE = 0, | |
724 | HE_RESTORE = 1, | |
725 | HE_CANCEL = 2, | |
726 | HE_RELEASE = 3, | |
727 | HE_REMOVE = 4, | |
728 | HE_STATE = 5, | |
729 | HE_SPARE1 = 6, | |
730 | HE_SPARE2 = 7, | |
731 | }; | |
732 | ||
733 | static inline enum hsm_event hsm_get_cl_event(__u16 flags) | |
734 | { | |
735 | return CLF_GET_BITS(flags, CLF_HSM_EVENT_H, CLF_HSM_EVENT_L); | |
736 | } | |
737 | ||
738 | static inline void hsm_set_cl_event(int *flags, enum hsm_event he) | |
739 | { | |
740 | *flags |= (he << CLF_HSM_EVENT_L); | |
741 | } | |
742 | ||
743 | static inline __u16 hsm_get_cl_flags(int flags) | |
744 | { | |
745 | return CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L); | |
746 | } | |
747 | ||
748 | static inline void hsm_set_cl_flags(int *flags, int bits) | |
749 | { | |
750 | *flags |= (bits << CLF_HSM_FLAG_L); | |
751 | } | |
752 | ||
753 | static inline int hsm_get_cl_error(int flags) | |
754 | { | |
755 | return CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L); | |
756 | } | |
757 | ||
758 | static inline void hsm_set_cl_error(int *flags, int error) | |
759 | { | |
760 | *flags |= (error << CLF_HSM_ERR_L); | |
761 | } | |
762 | ||
910827f1 OD |
763 | #define CR_MAXSIZE cfs_size_round(2*NAME_MAX + 1 + \ |
764 | sizeof(struct changelog_ext_rec)) | |
d7e09d03 PT |
765 | |
766 | struct changelog_rec { | |
767 | __u16 cr_namelen; | |
768 | __u16 cr_flags; /**< (flags&CLF_FLAGMASK)|CLF_VERSION */ | |
769 | __u32 cr_type; /**< \a changelog_rec_type */ | |
770 | __u64 cr_index; /**< changelog record number */ | |
771 | __u64 cr_prev; /**< last index for this target fid */ | |
772 | __u64 cr_time; | |
773 | union { | |
774 | lustre_fid cr_tfid; /**< target fid */ | |
775 | __u32 cr_markerflags; /**< CL_MARK flags */ | |
776 | }; | |
777 | lustre_fid cr_pfid; /**< parent fid */ | |
778 | char cr_name[0]; /**< last element */ | |
779 | } __attribute__((packed)); | |
780 | ||
781 | /* changelog_ext_rec is 2*sizeof(lu_fid) bigger than changelog_rec, to save | |
782 | * space, only rename uses changelog_ext_rec, while others use changelog_rec to | |
783 | * store records. | |
784 | */ | |
785 | struct changelog_ext_rec { | |
786 | __u16 cr_namelen; | |
787 | __u16 cr_flags; /**< (flags & CLF_FLAGMASK) | | |
788 | CLF_EXT_VERSION */ | |
789 | __u32 cr_type; /**< \a changelog_rec_type */ | |
790 | __u64 cr_index; /**< changelog record number */ | |
791 | __u64 cr_prev; /**< last index for this target fid */ | |
792 | __u64 cr_time; | |
793 | union { | |
794 | lustre_fid cr_tfid; /**< target fid */ | |
795 | __u32 cr_markerflags; /**< CL_MARK flags */ | |
796 | }; | |
797 | lustre_fid cr_pfid; /**< target parent fid */ | |
798 | lustre_fid cr_sfid; /**< source fid, or zero */ | |
799 | lustre_fid cr_spfid; /**< source parent fid, or zero */ | |
800 | char cr_name[0]; /**< last element */ | |
801 | } __attribute__((packed)); | |
802 | ||
803 | #define CHANGELOG_REC_EXTENDED(rec) \ | |
804 | (((rec)->cr_flags & CLF_VERMASK) == CLF_EXT_VERSION) | |
805 | ||
806 | static inline int changelog_rec_size(struct changelog_rec *rec) | |
807 | { | |
808 | return CHANGELOG_REC_EXTENDED(rec) ? sizeof(struct changelog_ext_rec): | |
809 | sizeof(*rec); | |
810 | } | |
811 | ||
812 | static inline char *changelog_rec_name(struct changelog_rec *rec) | |
813 | { | |
814 | return CHANGELOG_REC_EXTENDED(rec) ? | |
815 | ((struct changelog_ext_rec *)rec)->cr_name: rec->cr_name; | |
816 | } | |
817 | ||
818 | static inline int changelog_rec_snamelen(struct changelog_ext_rec *rec) | |
819 | { | |
820 | return rec->cr_namelen - strlen(rec->cr_name) - 1; | |
821 | } | |
822 | ||
823 | static inline char *changelog_rec_sname(struct changelog_ext_rec *rec) | |
824 | { | |
825 | return rec->cr_name + strlen(rec->cr_name) + 1; | |
826 | } | |
827 | ||
828 | struct ioc_changelog { | |
829 | __u64 icc_recno; | |
830 | __u32 icc_mdtindex; | |
831 | __u32 icc_id; | |
832 | __u32 icc_flags; | |
833 | }; | |
834 | ||
835 | enum changelog_message_type { | |
836 | CL_RECORD = 10, /* message is a changelog_rec */ | |
837 | CL_EOF = 11, /* at end of current changelog */ | |
838 | }; | |
839 | ||
840 | /********* Misc **********/ | |
841 | ||
842 | struct ioc_data_version { | |
843 | __u64 idv_version; | |
844 | __u64 idv_flags; /* See LL_DV_xxx */ | |
845 | }; | |
846 | #define LL_DV_NOFLUSH 0x01 /* Do not take READ EXTENT LOCK before sampling | |
847 | version. Dirty caches are left unchanged. */ | |
848 | ||
849 | #ifndef offsetof | |
850 | # define offsetof(typ,memb) ((unsigned long)((char *)&(((typ *)0)->memb))) | |
851 | #endif | |
852 | ||
853 | #define dot_lustre_name ".lustre" | |
854 | ||
855 | ||
856 | /********* HSM **********/ | |
857 | ||
858 | /** HSM per-file state | |
859 | * See HSM_FLAGS below. | |
860 | */ | |
861 | enum hsm_states { | |
862 | HS_EXISTS = 0x00000001, | |
863 | HS_DIRTY = 0x00000002, | |
864 | HS_RELEASED = 0x00000004, | |
865 | HS_ARCHIVED = 0x00000008, | |
866 | HS_NORELEASE = 0x00000010, | |
867 | HS_NOARCHIVE = 0x00000020, | |
868 | HS_LOST = 0x00000040, | |
869 | }; | |
870 | ||
871 | /* HSM user-setable flags. */ | |
872 | #define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY) | |
873 | ||
874 | /* Other HSM flags. */ | |
875 | #define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED) | |
876 | ||
877 | /* | |
878 | * All HSM-related possible flags that could be applied to a file. | |
879 | * This should be kept in sync with hsm_states. | |
880 | */ | |
881 | #define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK) | |
882 | ||
883 | /** | |
884 | * HSMÂ request progress state | |
885 | */ | |
886 | enum hsm_progress_states { | |
887 | HPS_WAITING = 1, | |
888 | HPS_RUNNING = 2, | |
889 | HPS_DONE = 3, | |
890 | }; | |
891 | #define HPS_NONE 0 | |
892 | ||
893 | static inline char *hsm_progress_state2name(enum hsm_progress_states s) | |
894 | { | |
895 | switch (s) { | |
896 | case HPS_WAITING: return "waiting"; | |
897 | case HPS_RUNNING: return "running"; | |
898 | case HPS_DONE: return "done"; | |
899 | default: return "unknown"; | |
900 | } | |
901 | } | |
902 | ||
903 | struct hsm_extent { | |
904 | __u64 offset; | |
905 | __u64 length; | |
906 | } __attribute__((packed)); | |
907 | ||
908 | /** | |
909 | * Current HSM states of a Lustre file. | |
910 | * | |
911 | * This structure purpose is to be sent to user-space mainly. It describes the | |
912 | * current HSM flags and in-progress action. | |
913 | */ | |
914 | struct hsm_user_state { | |
915 | /** Current HSM states, from enum hsm_states. */ | |
916 | __u32 hus_states; | |
917 | __u32 hus_archive_id; | |
918 | /** The current undergoing action, if there is one */ | |
919 | __u32 hus_in_progress_state; | |
920 | __u32 hus_in_progress_action; | |
921 | struct hsm_extent hus_in_progress_location; | |
922 | char hus_extended_info[]; | |
923 | }; | |
924 | ||
925 | struct hsm_state_set_ioc { | |
926 | struct lu_fid hssi_fid; | |
927 | __u64 hssi_setmask; | |
928 | __u64 hssi_clearmask; | |
929 | }; | |
930 | ||
931 | /* | |
932 | * This structure describes the current in-progress action for a file. | |
933 | * it is retuned to user space and send over the wire | |
934 | */ | |
935 | struct hsm_current_action { | |
936 | /** The current undergoing action, if there is one */ | |
937 | /* state is one of hsm_progress_states */ | |
938 | __u32 hca_state; | |
939 | /* action is one of hsm_user_action */ | |
940 | __u32 hca_action; | |
941 | struct hsm_extent hca_location; | |
942 | }; | |
943 | ||
944 | /***** HSM user requests ******/ | |
945 | /* User-generated (lfs/ioctl) request types */ | |
946 | enum hsm_user_action { | |
947 | HUA_NONE = 1, /* no action (noop) */ | |
948 | HUA_ARCHIVE = 10, /* copy to hsm */ | |
949 | HUA_RESTORE = 11, /* prestage */ | |
950 | HUA_RELEASE = 12, /* drop ost objects */ | |
951 | HUA_REMOVE = 13, /* remove from archive */ | |
952 | HUA_CANCEL = 14 /* cancel a request */ | |
953 | }; | |
954 | ||
955 | static inline char *hsm_user_action2name(enum hsm_user_action a) | |
956 | { | |
957 | switch (a) { | |
958 | case HUA_NONE: return "NOOP"; | |
959 | case HUA_ARCHIVE: return "ARCHIVE"; | |
960 | case HUA_RESTORE: return "RESTORE"; | |
961 | case HUA_RELEASE: return "RELEASE"; | |
962 | case HUA_REMOVE: return "REMOVE"; | |
963 | case HUA_CANCEL: return "CANCEL"; | |
964 | default: return "UNKNOWN"; | |
965 | } | |
966 | } | |
967 | ||
968 | /* | |
969 | * List of hr_flags (bit field) | |
970 | */ | |
971 | #define HSM_FORCE_ACTION 0x0001 | |
972 | /* used by CT, connot be set by user */ | |
973 | #define HSM_GHOST_COPY 0x0002 | |
974 | ||
975 | /** | |
976 | * Contains all the fixed part of struct hsm_user_request. | |
977 | * | |
978 | */ | |
979 | struct hsm_request { | |
980 | __u32 hr_action; /* enum hsm_user_action */ | |
981 | __u32 hr_archive_id; /* archive id, used only with HUA_ARCHIVE */ | |
982 | __u64 hr_flags; /* request flags */ | |
983 | __u32 hr_itemcount; /* item count in hur_user_item vector */ | |
984 | __u32 hr_data_len; | |
985 | }; | |
986 | ||
987 | struct hsm_user_item { | |
988 | lustre_fid hui_fid; | |
989 | struct hsm_extent hui_extent; | |
990 | } __attribute__((packed)); | |
991 | ||
992 | struct hsm_user_request { | |
993 | struct hsm_request hur_request; | |
994 | struct hsm_user_item hur_user_item[0]; | |
995 | /* extra data blob at end of struct (after all | |
996 | * hur_user_items), only use helpers to access it | |
997 | */ | |
998 | } __attribute__((packed)); | |
999 | ||
1000 | /** Return pointer to data field in a hsm user request */ | |
1001 | static inline void *hur_data(struct hsm_user_request *hur) | |
1002 | { | |
1003 | return &(hur->hur_user_item[hur->hur_request.hr_itemcount]); | |
1004 | } | |
1005 | ||
1006 | /** Compute the current length of the provided hsm_user_request. */ | |
1007 | static inline int hur_len(struct hsm_user_request *hur) | |
1008 | { | |
1009 | return offsetof(struct hsm_user_request, | |
1010 | hur_user_item[hur->hur_request.hr_itemcount]) + | |
1011 | hur->hur_request.hr_data_len; | |
1012 | } | |
1013 | ||
1014 | /****** HSM RPCs to copytool *****/ | |
1015 | /* Message types the copytool may receive */ | |
1016 | enum hsm_message_type { | |
1017 | HMT_ACTION_LIST = 100, /* message is a hsm_action_list */ | |
1018 | }; | |
1019 | ||
1020 | /* Actions the copytool may be instructed to take for a given action_item */ | |
1021 | enum hsm_copytool_action { | |
1022 | HSMA_NONE = 10, /* no action */ | |
1023 | HSMA_ARCHIVE = 20, /* arbitrary offset */ | |
1024 | HSMA_RESTORE = 21, | |
1025 | HSMA_REMOVE = 22, | |
1026 | HSMA_CANCEL = 23 | |
1027 | }; | |
1028 | ||
1029 | static inline char *hsm_copytool_action2name(enum hsm_copytool_action a) | |
1030 | { | |
1031 | switch (a) { | |
1032 | case HSMA_NONE: return "NOOP"; | |
1033 | case HSMA_ARCHIVE: return "ARCHIVE"; | |
1034 | case HSMA_RESTORE: return "RESTORE"; | |
1035 | case HSMA_REMOVE: return "REMOVE"; | |
1036 | case HSMA_CANCEL: return "CANCEL"; | |
1037 | default: return "UNKNOWN"; | |
1038 | } | |
1039 | } | |
1040 | ||
1041 | /* Copytool item action description */ | |
1042 | struct hsm_action_item { | |
1043 | __u32 hai_len; /* valid size of this struct */ | |
1044 | __u32 hai_action; /* hsm_copytool_action, but use known size */ | |
1045 | lustre_fid hai_fid; /* Lustre FID to operated on */ | |
1046 | lustre_fid hai_dfid; /* fid used for data access */ | |
1047 | struct hsm_extent hai_extent; /* byte range to operate on */ | |
1048 | __u64 hai_cookie; /* action cookie from coordinator */ | |
1049 | __u64 hai_gid; /* grouplock id */ | |
1050 | char hai_data[0]; /* variable length */ | |
1051 | } __attribute__((packed)); | |
1052 | ||
1053 | /* | |
1054 | * helper function which print in hexa the first bytes of | |
1055 | * hai opaque field | |
1056 | * \param hai [IN] record to print | |
1057 | * \param buffer [OUT] output buffer | |
1058 | * \param len [IN] max buffer len | |
1059 | * \retval buffer | |
1060 | */ | |
1061 | static inline char *hai_dump_data_field(struct hsm_action_item *hai, | |
1062 | char *buffer, int len) | |
1063 | { | |
1064 | int i, sz, data_len; | |
1065 | char *ptr; | |
1066 | ||
1067 | ptr = buffer; | |
1068 | sz = len; | |
1069 | data_len = hai->hai_len - sizeof(*hai); | |
1070 | for (i = 0 ; (i < data_len) && (sz > 0) ; i++) | |
1071 | { | |
1072 | int cnt; | |
1073 | ||
1074 | cnt = snprintf(ptr, sz, "%.2X", | |
1075 | (unsigned char)hai->hai_data[i]); | |
1076 | ptr += cnt; | |
1077 | sz -= cnt; | |
1078 | } | |
1079 | *ptr = '\0'; | |
1080 | return buffer; | |
1081 | } | |
1082 | ||
1083 | /* Copytool action list */ | |
1084 | #define HAL_VERSION 1 | |
1085 | #define HAL_MAXSIZE LNET_MTU /* bytes, used in userspace only */ | |
1086 | struct hsm_action_list { | |
1087 | __u32 hal_version; | |
1088 | __u32 hal_count; /* number of hai's to follow */ | |
1089 | __u64 hal_compound_id; /* returned by coordinator */ | |
1090 | __u64 hal_flags; | |
1091 | __u32 hal_archive_id; /* which archive backend */ | |
1092 | __u32 padding1; | |
1093 | char hal_fsname[0]; /* null-terminated */ | |
1094 | /* struct hsm_action_item[hal_count] follows, aligned on 8-byte | |
1095 | boundaries. See hai_zero */ | |
1096 | } __attribute__((packed)); | |
1097 | ||
1098 | #ifndef HAVE_CFS_SIZE_ROUND | |
1099 | static inline int cfs_size_round (int val) | |
1100 | { | |
1101 | return (val + 7) & (~0x7); | |
1102 | } | |
1103 | #define HAVE_CFS_SIZE_ROUND | |
1104 | #endif | |
1105 | ||
1106 | /* Return pointer to first hai in action list */ | |
1107 | static inline struct hsm_action_item * hai_zero(struct hsm_action_list *hal) | |
1108 | { | |
1109 | return (struct hsm_action_item *)(hal->hal_fsname + | |
1110 | cfs_size_round(strlen(hal-> \ | |
1111 | hal_fsname))); | |
1112 | } | |
1113 | /* Return pointer to next hai */ | |
1114 | static inline struct hsm_action_item * hai_next(struct hsm_action_item *hai) | |
1115 | { | |
1116 | return (struct hsm_action_item *)((char *)hai + | |
1117 | cfs_size_round(hai->hai_len)); | |
1118 | } | |
1119 | ||
1120 | /* Return size of an hsm_action_list */ | |
1121 | static inline int hal_size(struct hsm_action_list *hal) | |
1122 | { | |
1123 | int i, sz; | |
1124 | struct hsm_action_item *hai; | |
1125 | ||
1126 | sz = sizeof(*hal) + cfs_size_round(strlen(hal->hal_fsname)); | |
1127 | hai = hai_zero(hal); | |
18dfaebf | 1128 | for (i = 0; i < hal->hal_count; i++, hai = hai_next(hai)) |
d7e09d03 | 1129 | sz += cfs_size_round(hai->hai_len); |
18dfaebf JL |
1130 | |
1131 | return sz; | |
d7e09d03 PT |
1132 | } |
1133 | ||
a720b790 JL |
1134 | /* HSM file import |
1135 | * describe the attributes to be set on imported file | |
1136 | */ | |
1137 | struct hsm_user_import { | |
1138 | __u64 hui_size; | |
1139 | __u64 hui_atime; | |
1140 | __u64 hui_mtime; | |
1141 | __u32 hui_atime_ns; | |
1142 | __u32 hui_mtime_ns; | |
1143 | __u32 hui_uid; | |
1144 | __u32 hui_gid; | |
1145 | __u32 hui_mode; | |
1146 | __u32 hui_archive_id; | |
1147 | }; | |
1148 | ||
d7e09d03 PT |
1149 | /* Copytool progress reporting */ |
1150 | #define HP_FLAG_COMPLETED 0x01 | |
1151 | #define HP_FLAG_RETRY 0x02 | |
1152 | ||
1153 | struct hsm_progress { | |
1154 | lustre_fid hp_fid; | |
1155 | __u64 hp_cookie; | |
1156 | struct hsm_extent hp_extent; | |
1157 | __u16 hp_flags; | |
1158 | __u16 hp_errval; /* positive val */ | |
1159 | __u32 padding; | |
1160 | }; | |
1161 | ||
1162 | /** | |
1163 | * Use by copytool during any hsm request they handled. | |
1164 | * This structure is initialized by llapi_hsm_copy_start() | |
1165 | * which is an helper over the ioctl() interface | |
1166 | * Store Lustre, internal use only, data. | |
1167 | */ | |
1168 | struct hsm_copy { | |
1169 | __u64 hc_data_version; | |
1170 | __u16 hc_flags; | |
1171 | __u16 hc_errval; /* positive val */ | |
1172 | __u32 padding; | |
1173 | struct hsm_action_item hc_hai; | |
1174 | }; | |
1175 | ||
1176 | /** @} lustreuser */ | |
1177 | ||
1178 | #endif /* _LUSTRE_USER_H */ |