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