1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#ifndef _LUSTRE_USER_H
42#define _LUSTRE_USER_H
43
44
45
46
47
48
49#include <lustre/ll_fiemap.h>
50#include <linux/lustre_user.h>
51
52
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
66#define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER)
67
68enum obd_statfs_state {
69 OS_STATE_DEGRADED = 0x00000001,
70 OS_STATE_READONLY = 0x00000002,
71 OS_STATE_RDONLY_1 = 0x00000004,
72 OS_STATE_RDONLY_2 = 0x00000008,
73 OS_STATE_RDONLY_3 = 0x00000010,
74};
75
76struct 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;
88 __u32 os_fprecreated;
89
90
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
103
104
105
106
107struct lu_fid {
108
109
110
111
112
113
114 __u64 f_seq;
115
116 __u32 f_oid;
117
118
119
120
121
122 __u32 f_ver;
123};
124
125struct filter_fid {
126 struct lu_fid ff_parent;
127};
128
129
130struct filter_fid_old {
131 struct lu_fid ff_parent;
132 __u64 ff_objid;
133 __u64 ff_seq;
134};
135
136
137
138
139typedef struct lu_fid lustre_fid;
140
141
142
143
144
145
146struct lustre_mdt_attrs {
147
148
149
150
151 __u32 lma_compat;
152
153
154
155
156
157 __u32 lma_incompat;
158
159 struct lu_fid lma_self_fid;
160};
161
162
163
164
165
166
167#define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64))
168
169
170
171
172struct 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
187
188
189
190
191
192
193
194
195
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
200#define LL_IOC_LOV_SETSTRIPE _IOW ('f', 154, long)
201
202#define LL_IOC_LOV_GETSTRIPE _IOW ('f', 155, long)
203
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
210#define LL_IOC_QUOTACHECK _IOW ('f', 160, int)
211
212#define LL_IOC_POLL_QUOTACHECK _IOR ('f', 161, struct if_quotacheck *)
213
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
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
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)
247
248#define LL_STATFS_LMV 1
249#define LL_STATFS_LOV 2
250#define LL_STATFS_NODELAY 4
251
252#define IOC_MDC_TYPE 'i'
253#define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *)
254#define IOC_MDC_GETFILESTRIPE _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *)
255#define IOC_MDC_GETFILEINFO _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data *)
256#define LL_IOC_MDC_GETINFO _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data *)
257
258
259#define LL_IOC_OBD_STATFS IOC_OBD_STATFS
260#define IOC_MDC_GETSTRIPE IOC_MDC_GETFILESTRIPE
261
262
263#define MAX_OBD_NAME 128
264
265
266
267
268
269
270
271#define O_LOV_DELAY_CREATE 0120000000
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
277#define LL_FILE_LOCKLESS_IO 0x00000010
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
286#define LMV_USER_MAGIC 0x0CD20CD0
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
296#define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS)
297#define LOV_MAX_STRIPE_COUNT_OLD 160
298
299
300
301
302
303
304
305
306
307#define LOV_MAX_STRIPE_COUNT 2000
308#define LOV_ALL_STRIPES 0xffff
309#define LOV_V1_INSANE_STRIPE_COUNT 65532
310
311#define lov_user_ost_data lov_user_ost_data_v1
312struct lov_user_ost_data_v1 {
313 struct ost_id l_ost_oi;
314 __u32 l_ost_gen;
315 __u32 l_ost_idx;
316} __attribute__((packed));
317
318#define lov_user_md lov_user_md_v1
319struct lov_user_md_v1 {
320 __u32 lmm_magic;
321 __u32 lmm_pattern;
322 struct ost_id lmm_oi;
323 __u32 lmm_stripe_size;
324 __u16 lmm_stripe_count;
325 union {
326 __u16 lmm_stripe_offset;
327
328 __u16 lmm_layout_gen;
329
330 };
331 struct lov_user_ost_data_v1 lmm_objects[0];
332} __attribute__((packed, __may_alias__));
333
334struct lov_user_md_v3 {
335 __u32 lmm_magic;
336 __u32 lmm_pattern;
337 struct ost_id lmm_oi;
338 __u32 lmm_stripe_size;
339 __u16 lmm_stripe_count;
340 union {
341 __u16 lmm_stripe_offset;
342
343 __u16 lmm_layout_gen;
344
345 };
346 char lmm_pool_name[LOV_MAXPOOLNAME];
347 struct lov_user_ost_data_v1 lmm_objects[0];
348} __attribute__((packed));
349
350static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic)
351{
352 if (lmm_magic == LOV_USER_MAGIC_V3)
353 return sizeof(struct lov_user_md_v3) +
354 stripes * sizeof(struct lov_user_ost_data_v1);
355 else
356 return sizeof(struct lov_user_md_v1) +
357 stripes * sizeof(struct lov_user_ost_data_v1);
358}
359
360
361
362
363#ifdef HAVE_LOV_USER_MDS_DATA
364#define lov_user_mds_data lov_user_mds_data_v1
365struct lov_user_mds_data_v1 {
366 lstat_t lmd_st;
367 struct lov_user_md_v1 lmd_lmm;
368} __attribute__((packed));
369
370struct lov_user_mds_data_v3 {
371 lstat_t lmd_st;
372 struct lov_user_md_v3 lmd_lmm;
373} __attribute__((packed));
374#endif
375
376
377struct lmv_user_mds_data {
378 struct lu_fid lum_fid;
379 __u32 lum_padding;
380 __u32 lum_mds;
381};
382
383
384enum {
385 LMV_STRIPE_TYPE = 0,
386 LMV_DEFAULT_TYPE = 1,
387};
388
389#define lmv_user_md lmv_user_md_v1
390struct lmv_user_md_v1 {
391 __u32 lum_magic;
392 __u32 lum_stripe_count;
393 __u32 lum_stripe_offset;
394 __u32 lum_hash_type;
395 __u32 lum_type;
396 __u32 lum_padding1;
397 __u32 lum_padding2;
398 __u32 lum_padding3;
399 char lum_pool_name[LOV_MAXPOOLNAME];
400 struct lmv_user_mds_data lum_objects[0];
401};
402
403static inline int lmv_user_md_size(int stripes, int lmm_magic)
404{
405 return sizeof(struct lmv_user_md) +
406 stripes * sizeof(struct lmv_user_mds_data);
407}
408
409extern void lustre_swab_lmv_user_md(struct lmv_user_md *lum);
410
411struct ll_recreate_obj {
412 __u64 lrc_id;
413 __u32 lrc_ost_idx;
414};
415
416struct ll_fid {
417 __u64 id;
418 __u32 generation;
419 __u32 f_type;
420
421};
422
423#define UUID_MAX 40
424struct obd_uuid {
425 char uuid[UUID_MAX];
426};
427
428static inline int obd_uuid_equals(const struct obd_uuid *u1,
429 const struct obd_uuid *u2)
430{
431 return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
432}
433
434static inline int obd_uuid_empty(struct obd_uuid *uuid)
435{
436 return uuid->uuid[0] == '\0';
437}
438
439static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp)
440{
441 strncpy((char *)uuid->uuid, tmp, sizeof(*uuid));
442 uuid->uuid[sizeof(*uuid) - 1] = '\0';
443}
444
445
446static inline char *obd_uuid2str(struct obd_uuid *uuid)
447{
448 if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
449
450
451 static char temp[sizeof(*uuid)];
452 memcpy(temp, uuid->uuid, sizeof(*uuid) - 1);
453 temp[sizeof(*uuid) - 1] = '\0';
454 return temp;
455 }
456 return (char *)(uuid->uuid);
457}
458
459
460
461
462static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen)
463{
464 char *p;
465
466 strncpy(buf, uuid, buflen - 1);
467 buf[buflen - 1] = '\0';
468 p = strrchr(buf, '-');
469 if (p)
470 *p = '\0';
471}
472
473
474
475#define FID_NOBRACE_LEN 40
476#define FID_LEN (FID_NOBRACE_LEN + 2)
477#define DFID_NOBRACE LPX64":0x%x:0x%x"
478#define DFID "["DFID_NOBRACE"]"
479#define PFID(fid) \
480 (fid)->f_seq, \
481 (fid)->f_oid, \
482 (fid)->f_ver
483
484
485
486
487
488
489
490#define SFID "0x"LPX64i":0x%x:0x%x"
491#define RFID(fid) \
492 &((fid)->f_seq), \
493 &((fid)->f_oid), \
494 &((fid)->f_ver)
495
496
497
498
499
500#define LUSTRE_Q_QUOTAON 0x800002
501#define LUSTRE_Q_QUOTAOFF 0x800003
502#define LUSTRE_Q_GETINFO 0x800005
503#define LUSTRE_Q_SETINFO 0x800006
504#define LUSTRE_Q_GETQUOTA 0x800007
505#define LUSTRE_Q_SETQUOTA 0x800008
506
507#define LUSTRE_Q_INVALIDATE 0x80000b
508#define LUSTRE_Q_FINVALIDATE 0x80000c
509
510#define UGQUOTA 2
511
512struct if_quotacheck {
513 char obd_type[16];
514 struct obd_uuid obd_uuid;
515};
516
517#define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
518
519
520#define N_PERMS_MAX 64
521
522struct perm_downcall_data {
523 __u64 pdd_nid;
524 __u32 pdd_perm;
525 __u32 pdd_padding;
526};
527
528struct identity_downcall_data {
529 __u32 idd_magic;
530 __u32 idd_err;
531 __u32 idd_uid;
532 __u32 idd_gid;
533 __u32 idd_nperms;
534 __u32 idd_ngroups;
535 struct perm_downcall_data idd_perms[N_PERMS_MAX];
536 __u32 idd_groups[0];
537};
538
539
540#define NOBODY_UID 99
541#define NOBODY_GID 99
542
543#define INVALID_ID (-1)
544
545enum {
546 RMT_LSETFACL = 1,
547 RMT_LGETFACL = 2,
548 RMT_RSETFACL = 3,
549 RMT_RGETFACL = 4
550};
551
552#ifdef NEED_QUOTA_DEFS
553#ifndef QIF_BLIMITS
554#define QIF_BLIMITS 1
555#define QIF_SPACE 2
556#define QIF_ILIMITS 4
557#define QIF_INODES 8
558#define QIF_BTIME 16
559#define QIF_ITIME 32
560#define QIF_LIMITS (QIF_BLIMITS | QIF_ILIMITS)
561#define QIF_USAGE (QIF_SPACE | QIF_INODES)
562#define QIF_TIMES (QIF_BTIME | QIF_ITIME)
563#define QIF_ALL (QIF_LIMITS | QIF_USAGE | QIF_TIMES)
564#endif
565
566#endif
567
568
569
570
571#define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE"
572#define LUSTRE_VOLATILE_HDR_LEN 14
573
574#define LUSTRE_VOLATILE_IDX LUSTRE_VOLATILE_HDR":%.4X:"
575
576typedef enum lustre_quota_version {
577 LUSTRE_QUOTA_V2 = 1
578} lustre_quota_version_t;
579
580
581struct obd_dqinfo {
582 __u64 dqi_bgrace;
583 __u64 dqi_igrace;
584 __u32 dqi_flags;
585 __u32 dqi_valid;
586};
587
588
589struct obd_dqblk {
590 __u64 dqb_bhardlimit;
591 __u64 dqb_bsoftlimit;
592 __u64 dqb_curspace;
593 __u64 dqb_ihardlimit;
594 __u64 dqb_isoftlimit;
595 __u64 dqb_curinodes;
596 __u64 dqb_btime;
597 __u64 dqb_itime;
598 __u32 dqb_valid;
599 __u32 dqb_padding;
600};
601
602enum {
603 QC_GENERAL = 0,
604 QC_MDTIDX = 1,
605 QC_OSTIDX = 2,
606 QC_UUID = 3
607};
608
609struct if_quotactl {
610 __u32 qc_cmd;
611 __u32 qc_type;
612 __u32 qc_id;
613 __u32 qc_stat;
614 __u32 qc_valid;
615 __u32 qc_idx;
616 struct obd_dqinfo qc_dqinfo;
617 struct obd_dqblk qc_dqblk;
618 char obd_type[16];
619 struct obd_uuid obd_uuid;
620};
621
622
623#define SWAP_LAYOUTS_CHECK_DV1 (1 << 0)
624#define SWAP_LAYOUTS_CHECK_DV2 (1 << 1)
625#define SWAP_LAYOUTS_KEEP_MTIME (1 << 2)
626#define SWAP_LAYOUTS_KEEP_ATIME (1 << 3)
627struct lustre_swap_layouts {
628 __u64 sl_flags;
629 __u32 sl_fd;
630 __u32 sl_gid;
631 __u64 sl_dv1;
632 __u64 sl_dv2;
633};
634
635
636
637
638enum changelog_rec_type {
639 CL_MARK = 0,
640 CL_CREATE = 1,
641 CL_MKDIR = 2,
642 CL_HARDLINK = 3,
643 CL_SOFTLINK = 4,
644 CL_MKNOD = 5,
645 CL_UNLINK = 6,
646 CL_RMDIR = 7,
647 CL_RENAME = 8,
648 CL_EXT = 9,
649 CL_OPEN = 10,
650 CL_CLOSE = 11,
651 CL_LAYOUT = 12,
652 CL_TRUNC = 13,
653 CL_SETATTR = 14,
654 CL_XATTR = 15,
655 CL_HSM = 16,
656 CL_MTIME = 17,
657 CL_CTIME = 18,
658 CL_ATIME = 19,
659 CL_LAST
660};
661
662static inline const char *changelog_type2str(int type) {
663 static const char *changelog_str[] = {
664 "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
665 "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC",
666 "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME",
667 };
668
669 if (type >= 0 && type < CL_LAST)
670 return changelog_str[type];
671 return NULL;
672}
673
674
675#define CLF_VERSION 0x1000
676#define CLF_EXT_VERSION 0x2000
677#define CLF_FLAGSHIFT 12
678#define CLF_FLAGMASK ((1U << CLF_FLAGSHIFT) - 1)
679#define CLF_VERMASK (~CLF_FLAGMASK)
680
681
682#define CLF_UNLINK_LAST 0x0001
683#define CLF_UNLINK_HSM_EXISTS 0x0002
684
685
686#define CLF_RENAME_LAST 0x0001
687
688
689
690
691
692
693
694#define CLF_HSM_ERR_L 0
695#define CLF_HSM_ERR_H 6
696#define CLF_HSM_EVENT_L 7
697#define CLF_HSM_EVENT_H 9
698#define CLF_HSM_FLAG_L 10
699#define CLF_HSM_FLAG_H 11
700#define CLF_HSM_SPARE_L 12
701#define CLF_HSM_SPARE_H 15
702#define CLF_HSM_LAST 15
703
704
705
706#define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \
707 >> (CLF_HSM_LAST - _h + _l))
708
709#define CLF_HSM_SUCCESS 0x00
710#define CLF_HSM_MAXERROR 0x7E
711#define CLF_HSM_ERROVERFLOW 0x7F
712
713#define CLF_HSM_DIRTY 1
714
715
716enum hsm_event {
717 HE_ARCHIVE = 0,
718 HE_RESTORE = 1,
719 HE_CANCEL = 2,
720 HE_RELEASE = 3,
721 HE_REMOVE = 4,
722 HE_STATE = 5,
723 HE_SPARE1 = 6,
724 HE_SPARE2 = 7,
725};
726
727static inline enum hsm_event hsm_get_cl_event(__u16 flags)
728{
729 return CLF_GET_BITS(flags, CLF_HSM_EVENT_H, CLF_HSM_EVENT_L);
730}
731
732static inline void hsm_set_cl_event(int *flags, enum hsm_event he)
733{
734 *flags |= (he << CLF_HSM_EVENT_L);
735}
736
737static inline __u16 hsm_get_cl_flags(int flags)
738{
739 return CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L);
740}
741
742static inline void hsm_set_cl_flags(int *flags, int bits)
743{
744 *flags |= (bits << CLF_HSM_FLAG_L);
745}
746
747static inline int hsm_get_cl_error(int flags)
748{
749 return CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L);
750}
751
752static inline void hsm_set_cl_error(int *flags, int error)
753{
754 *flags |= (error << CLF_HSM_ERR_L);
755}
756
757#define CR_MAXSIZE cfs_size_round(2*NAME_MAX + 1 + sizeof(struct changelog_rec))
758
759struct changelog_rec {
760 __u16 cr_namelen;
761 __u16 cr_flags;
762 __u32 cr_type;
763 __u64 cr_index;
764 __u64 cr_prev;
765 __u64 cr_time;
766 union {
767 lustre_fid cr_tfid;
768 __u32 cr_markerflags;
769 };
770 lustre_fid cr_pfid;
771 char cr_name[0];
772} __attribute__((packed));
773
774
775
776
777
778struct changelog_ext_rec {
779 __u16 cr_namelen;
780 __u16 cr_flags;
781
782 __u32 cr_type;
783 __u64 cr_index;
784 __u64 cr_prev;
785 __u64 cr_time;
786 union {
787 lustre_fid cr_tfid;
788 __u32 cr_markerflags;
789 };
790 lustre_fid cr_pfid;
791 lustre_fid cr_sfid;
792 lustre_fid cr_spfid;
793 char cr_name[0];
794} __attribute__((packed));
795
796#define CHANGELOG_REC_EXTENDED(rec) \
797 (((rec)->cr_flags & CLF_VERMASK) == CLF_EXT_VERSION)
798
799static inline int changelog_rec_size(struct changelog_rec *rec)
800{
801 return CHANGELOG_REC_EXTENDED(rec) ? sizeof(struct changelog_ext_rec):
802 sizeof(*rec);
803}
804
805static inline char *changelog_rec_name(struct changelog_rec *rec)
806{
807 return CHANGELOG_REC_EXTENDED(rec) ?
808 ((struct changelog_ext_rec *)rec)->cr_name: rec->cr_name;
809}
810
811static inline int changelog_rec_snamelen(struct changelog_ext_rec *rec)
812{
813 return rec->cr_namelen - strlen(rec->cr_name) - 1;
814}
815
816static inline char *changelog_rec_sname(struct changelog_ext_rec *rec)
817{
818 return rec->cr_name + strlen(rec->cr_name) + 1;
819}
820
821struct ioc_changelog {
822 __u64 icc_recno;
823 __u32 icc_mdtindex;
824 __u32 icc_id;
825 __u32 icc_flags;
826};
827
828enum changelog_message_type {
829 CL_RECORD = 10,
830 CL_EOF = 11,
831};
832
833
834
835struct ioc_data_version {
836 __u64 idv_version;
837 __u64 idv_flags;
838};
839#define LL_DV_NOFLUSH 0x01
840
841
842#ifndef offsetof
843# define offsetof(typ,memb) ((unsigned long)((char *)&(((typ *)0)->memb)))
844#endif
845
846#define dot_lustre_name ".lustre"
847
848
849
850
851
852
853
854enum hsm_states {
855 HS_EXISTS = 0x00000001,
856 HS_DIRTY = 0x00000002,
857 HS_RELEASED = 0x00000004,
858 HS_ARCHIVED = 0x00000008,
859 HS_NORELEASE = 0x00000010,
860 HS_NOARCHIVE = 0x00000020,
861 HS_LOST = 0x00000040,
862};
863
864
865#define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
866
867
868#define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
869
870
871
872
873
874#define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK)
875
876
877
878
879enum hsm_progress_states {
880 HPS_WAITING = 1,
881 HPS_RUNNING = 2,
882 HPS_DONE = 3,
883};
884#define HPS_NONE 0
885
886static inline char *hsm_progress_state2name(enum hsm_progress_states s)
887{
888 switch (s) {
889 case HPS_WAITING: return "waiting";
890 case HPS_RUNNING: return "running";
891 case HPS_DONE: return "done";
892 default: return "unknown";
893 }
894}
895
896struct hsm_extent {
897 __u64 offset;
898 __u64 length;
899} __attribute__((packed));
900
901
902
903
904
905
906
907struct hsm_user_state {
908
909 __u32 hus_states;
910 __u32 hus_archive_id;
911
912 __u32 hus_in_progress_state;
913 __u32 hus_in_progress_action;
914 struct hsm_extent hus_in_progress_location;
915 char hus_extended_info[];
916};
917
918struct hsm_state_set_ioc {
919 struct lu_fid hssi_fid;
920 __u64 hssi_setmask;
921 __u64 hssi_clearmask;
922};
923
924
925
926
927
928struct hsm_current_action {
929
930
931 __u32 hca_state;
932
933 __u32 hca_action;
934 struct hsm_extent hca_location;
935};
936
937
938
939enum hsm_user_action {
940 HUA_NONE = 1,
941 HUA_ARCHIVE = 10,
942 HUA_RESTORE = 11,
943 HUA_RELEASE = 12,
944 HUA_REMOVE = 13,
945 HUA_CANCEL = 14
946};
947
948static inline char *hsm_user_action2name(enum hsm_user_action a)
949{
950 switch (a) {
951 case HUA_NONE: return "NOOP";
952 case HUA_ARCHIVE: return "ARCHIVE";
953 case HUA_RESTORE: return "RESTORE";
954 case HUA_RELEASE: return "RELEASE";
955 case HUA_REMOVE: return "REMOVE";
956 case HUA_CANCEL: return "CANCEL";
957 default: return "UNKNOWN";
958 }
959}
960
961
962
963
964#define HSM_FORCE_ACTION 0x0001
965
966#define HSM_GHOST_COPY 0x0002
967
968
969
970
971
972struct hsm_request {
973 __u32 hr_action;
974 __u32 hr_archive_id;
975 __u64 hr_flags;
976 __u32 hr_itemcount;
977 __u32 hr_data_len;
978};
979
980struct hsm_user_item {
981 lustre_fid hui_fid;
982 struct hsm_extent hui_extent;
983} __attribute__((packed));
984
985struct hsm_user_request {
986 struct hsm_request hur_request;
987 struct hsm_user_item hur_user_item[0];
988
989
990
991} __attribute__((packed));
992
993
994static inline void *hur_data(struct hsm_user_request *hur)
995{
996 return &(hur->hur_user_item[hur->hur_request.hr_itemcount]);
997}
998
999
1000static inline int hur_len(struct hsm_user_request *hur)
1001{
1002 return offsetof(struct hsm_user_request,
1003 hur_user_item[hur->hur_request.hr_itemcount]) +
1004 hur->hur_request.hr_data_len;
1005}
1006
1007
1008
1009enum hsm_message_type {
1010 HMT_ACTION_LIST = 100,
1011};
1012
1013
1014enum hsm_copytool_action {
1015 HSMA_NONE = 10,
1016 HSMA_ARCHIVE = 20,
1017 HSMA_RESTORE = 21,
1018 HSMA_REMOVE = 22,
1019 HSMA_CANCEL = 23
1020};
1021
1022static inline char *hsm_copytool_action2name(enum hsm_copytool_action a)
1023{
1024 switch (a) {
1025 case HSMA_NONE: return "NOOP";
1026 case HSMA_ARCHIVE: return "ARCHIVE";
1027 case HSMA_RESTORE: return "RESTORE";
1028 case HSMA_REMOVE: return "REMOVE";
1029 case HSMA_CANCEL: return "CANCEL";
1030 default: return "UNKNOWN";
1031 }
1032}
1033
1034
1035struct hsm_action_item {
1036 __u32 hai_len;
1037 __u32 hai_action;
1038 lustre_fid hai_fid;
1039 lustre_fid hai_dfid;
1040 struct hsm_extent hai_extent;
1041 __u64 hai_cookie;
1042 __u64 hai_gid;
1043 char hai_data[0];
1044} __attribute__((packed));
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054static inline char *hai_dump_data_field(struct hsm_action_item *hai,
1055 char *buffer, int len)
1056{
1057 int i, sz, data_len;
1058 char *ptr;
1059
1060 ptr = buffer;
1061 sz = len;
1062 data_len = hai->hai_len - sizeof(*hai);
1063 for (i = 0 ; (i < data_len) && (sz > 0) ; i++)
1064 {
1065 int cnt;
1066
1067 cnt = snprintf(ptr, sz, "%.2X",
1068 (unsigned char)hai->hai_data[i]);
1069 ptr += cnt;
1070 sz -= cnt;
1071 }
1072 *ptr = '\0';
1073 return buffer;
1074}
1075
1076
1077#define HAL_VERSION 1
1078#define HAL_MAXSIZE LNET_MTU
1079struct hsm_action_list {
1080 __u32 hal_version;
1081 __u32 hal_count;
1082 __u64 hal_compound_id;
1083 __u64 hal_flags;
1084 __u32 hal_archive_id;
1085 __u32 padding1;
1086 char hal_fsname[0];
1087
1088
1089} __attribute__((packed));
1090
1091#ifndef HAVE_CFS_SIZE_ROUND
1092static inline int cfs_size_round (int val)
1093{
1094 return (val + 7) & (~0x7);
1095}
1096#define HAVE_CFS_SIZE_ROUND
1097#endif
1098
1099
1100static inline struct hsm_action_item * hai_zero(struct hsm_action_list *hal)
1101{
1102 return (struct hsm_action_item *)(hal->hal_fsname +
1103 cfs_size_round(strlen(hal-> \
1104 hal_fsname)));
1105}
1106
1107static inline struct hsm_action_item * hai_next(struct hsm_action_item *hai)
1108{
1109 return (struct hsm_action_item *)((char *)hai +
1110 cfs_size_round(hai->hai_len));
1111}
1112
1113
1114static inline int hal_size(struct hsm_action_list *hal)
1115{
1116 int i, sz;
1117 struct hsm_action_item *hai;
1118
1119 sz = sizeof(*hal) + cfs_size_round(strlen(hal->hal_fsname));
1120 hai = hai_zero(hal);
1121 for (i = 0 ; i < hal->hal_count ; i++) {
1122 sz += cfs_size_round(hai->hai_len);
1123 hai = hai_next(hai);
1124 }
1125 return(sz);
1126}
1127
1128
1129#define HP_FLAG_COMPLETED 0x01
1130#define HP_FLAG_RETRY 0x02
1131
1132struct hsm_progress {
1133 lustre_fid hp_fid;
1134 __u64 hp_cookie;
1135 struct hsm_extent hp_extent;
1136 __u16 hp_flags;
1137 __u16 hp_errval;
1138 __u32 padding;
1139};
1140
1141
1142
1143
1144
1145
1146
1147struct hsm_copy {
1148 __u64 hc_data_version;
1149 __u16 hc_flags;
1150 __u16 hc_errval;
1151 __u32 padding;
1152 struct hsm_action_item hc_hai;
1153};
1154
1155
1156
1157#endif
1158