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 "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 __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
102
103
104
105
106struct lu_fid {
107
108
109
110
111
112
113 __u64 f_seq;
114
115 __u32 f_oid;
116
117
118
119
120
121 __u32 f_ver;
122};
123
124struct filter_fid {
125 struct lu_fid ff_parent;
126};
127
128
129struct filter_fid_old {
130 struct lu_fid ff_parent;
131 __u64 ff_objid;
132 __u64 ff_seq;
133};
134
135
136
137
138
139struct lu_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 "%#llx:%llu"
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_SET_LEASE _IOWR('f', 243, long)
247#define LL_IOC_GET_LEASE _IO('f', 244)
248#define LL_IOC_HSM_IMPORT _IOWR('f', 245, struct hsm_user_import)
249
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
261#define LL_IOC_OBD_STATFS IOC_OBD_STATFS
262#define IOC_MDC_GETSTRIPE IOC_MDC_GETFILESTRIPE
263
264#define MAX_OBD_NAME 128
265
266
267
268
269
270
271#define O_LOV_DELAY_CREATE (O_NOCTTY | FASYNC)
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
308#define LOV_MAX_STRIPE_COUNT 2000
309#define LOV_ALL_STRIPES 0xffff
310#define LOV_V1_INSANE_STRIPE_COUNT 65532
311
312#define lov_user_ost_data lov_user_ost_data_v1
313struct lov_user_ost_data_v1 {
314 struct ost_id l_ost_oi;
315 __u32 l_ost_gen;
316 __u32 l_ost_idx;
317} __packed;
318
319#define lov_user_md lov_user_md_v1
320struct lov_user_md_v1 {
321 __u32 lmm_magic;
322 __u32 lmm_pattern;
323 struct ost_id lmm_oi;
324 __u32 lmm_stripe_size;
325 __u16 lmm_stripe_count;
326 union {
327 __u16 lmm_stripe_offset;
328
329
330 __u16 lmm_layout_gen;
331
332
333 };
334 struct lov_user_ost_data_v1 lmm_objects[0];
335} __attribute__((packed, __may_alias__));
336
337struct lov_user_md_v3 {
338 __u32 lmm_magic;
339 __u32 lmm_pattern;
340 struct ost_id lmm_oi;
341 __u32 lmm_stripe_size;
342 __u16 lmm_stripe_count;
343 union {
344 __u16 lmm_stripe_offset;
345
346
347 __u16 lmm_layout_gen;
348
349
350 };
351 char lmm_pool_name[LOV_MAXPOOLNAME];
352 struct lov_user_ost_data_v1 lmm_objects[0];
353} __packed;
354
355static 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
365
366
367
368#ifdef HAVE_LOV_USER_MDS_DATA
369#define lov_user_mds_data lov_user_mds_data_v1
370struct lov_user_mds_data_v1 {
371 lstat_t lmd_st;
372 struct lov_user_md_v1 lmd_lmm;
373} __packed;
374
375struct lov_user_mds_data_v3 {
376 lstat_t lmd_st;
377 struct lov_user_md_v3 lmd_lmm;
378} __packed;
379#endif
380
381
382struct lmv_user_mds_data {
383 struct lu_fid lum_fid;
384 __u32 lum_padding;
385 __u32 lum_mds;
386};
387
388
389enum {
390 LMV_STRIPE_TYPE = 0,
391 LMV_DEFAULT_TYPE = 1,
392};
393
394#define lmv_user_md lmv_user_md_v1
395struct lmv_user_md_v1 {
396 __u32 lum_magic;
397 __u32 lum_stripe_count;
398 __u32 lum_stripe_offset;
399 __u32 lum_hash_type;
400 __u32 lum_type;
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
408static 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
414struct ll_recreate_obj {
415 __u64 lrc_id;
416 __u32 lrc_ost_idx;
417};
418
419struct ll_fid {
420 __u64 id;
421 __u32 generation;
422 __u32 f_type;
423
424};
425
426#define UUID_MAX 40
427struct obd_uuid {
428 char uuid[UUID_MAX];
429};
430
431static inline bool obd_uuid_equals(const struct obd_uuid *u1,
432 const struct obd_uuid *u2)
433{
434 return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
435}
436
437static inline int obd_uuid_empty(struct obd_uuid *uuid)
438{
439 return uuid->uuid[0] == '\0';
440}
441
442static 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
449static inline char *obd_uuid2str(const struct obd_uuid *uuid)
450{
451 if (!uuid)
452 return NULL;
453
454 if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
455
456
457
458 static char temp[sizeof(*uuid)];
459
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
468
469
470
471static 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)
479 *p = '\0';
480}
481
482
483
484
485#define FID_NOBRACE_LEN 40
486#define FID_LEN (FID_NOBRACE_LEN + 2)
487#define DFID_NOBRACE "%#llx:0x%x:0x%x"
488#define DFID "["DFID_NOBRACE"]"
489#define PFID(fid) \
490 (fid)->f_seq, \
491 (fid)->f_oid, \
492 (fid)->f_ver
493
494
495
496
497#define SFID "0x%llx:0x%x:0x%x"
498#define RFID(fid) \
499 &((fid)->f_seq), \
500 &((fid)->f_oid), \
501 &((fid)->f_ver)
502
503
504
505
506#define LUSTRE_Q_QUOTAON 0x800002
507#define LUSTRE_Q_QUOTAOFF 0x800003
508#define LUSTRE_Q_GETINFO 0x800005
509#define LUSTRE_Q_SETINFO 0x800006
510#define LUSTRE_Q_GETQUOTA 0x800007
511#define LUSTRE_Q_SETQUOTA 0x800008
512
513#define LUSTRE_Q_INVALIDATE 0x80000b
514#define LUSTRE_Q_FINVALIDATE 0x80000c
515
516#define UGQUOTA 2
517
518struct if_quotacheck {
519 char obd_type[16];
520 struct obd_uuid obd_uuid;
521};
522
523#define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
524
525
526#define N_PERMS_MAX 64
527
528struct perm_downcall_data {
529 __u64 pdd_nid;
530 __u32 pdd_perm;
531 __u32 pdd_padding;
532};
533
534struct 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
546#define NOBODY_UID 99
547#define NOBODY_GID 99
548
549#define INVALID_ID (-1)
550
551enum {
552 RMT_LSETFACL = 1,
553 RMT_LGETFACL = 2,
554 RMT_RSETFACL = 3,
555 RMT_RGETFACL = 4
556};
557
558
559
560
561#define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE"
562#define LUSTRE_VOLATILE_HDR_LEN 14
563
564#define LUSTRE_VOLATILE_IDX LUSTRE_VOLATILE_HDR":%.4X:"
565
566enum lustre_quota_version {
567 LUSTRE_QUOTA_V2 = 1
568};
569
570
571struct obd_dqinfo {
572 __u64 dqi_bgrace;
573 __u64 dqi_igrace;
574 __u32 dqi_flags;
575 __u32 dqi_valid;
576};
577
578
579struct 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
592enum {
593 QC_GENERAL = 0,
594 QC_MDTIDX = 1,
595 QC_OSTIDX = 2,
596 QC_UUID = 3
597};
598
599struct 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
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
619#define SWAP_LAYOUTS_MDS_HSM (1 << 31)
620struct 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
628
629
630enum changelog_rec_type {
631 CL_MARK = 0,
632 CL_CREATE = 1,
633 CL_MKDIR = 2,
634 CL_HARDLINK = 3,
635 CL_SOFTLINK = 4,
636 CL_MKNOD = 5,
637 CL_UNLINK = 6,
638 CL_RMDIR = 7,
639 CL_RENAME = 8,
640 CL_EXT = 9,
641 CL_OPEN = 10,
642 CL_CLOSE = 11,
643 CL_LAYOUT = 12,
644 CL_TRUNC = 13,
645 CL_SETATTR = 14,
646 CL_XATTR = 15,
647 CL_HSM = 16,
648 CL_MTIME = 17,
649 CL_CTIME = 18,
650 CL_ATIME = 19,
651 CL_LAST
652};
653
654static inline const char *changelog_type2str(int type)
655{
656 static const char *changelog_str[] = {
657 "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
658 "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC",
659 "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME",
660 };
661
662 if (type >= 0 && type < CL_LAST)
663 return changelog_str[type];
664 return NULL;
665}
666
667
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
674
675#define CLF_UNLINK_LAST 0x0001
676#define CLF_UNLINK_HSM_EXISTS 0x0002
677
678
679#define CLF_RENAME_LAST 0x0001
680
681
682
683
684
685
686
687#define CLF_HSM_ERR_L 0
688#define CLF_HSM_ERR_H 6
689#define CLF_HSM_EVENT_L 7
690#define CLF_HSM_EVENT_H 9
691#define CLF_HSM_FLAG_L 10
692#define CLF_HSM_FLAG_H 11
693#define CLF_HSM_SPARE_L 12
694#define CLF_HSM_SPARE_H 15
695#define CLF_HSM_LAST 15
696
697
698
699
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
708
709
710enum 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
721static 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
726static inline void hsm_set_cl_event(int *flags, enum hsm_event he)
727{
728 *flags |= (he << CLF_HSM_EVENT_L);
729}
730
731static 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
736static inline void hsm_set_cl_flags(int *flags, int bits)
737{
738 *flags |= (bits << CLF_HSM_FLAG_L);
739}
740
741static 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
746static inline void hsm_set_cl_error(int *flags, int error)
747{
748 *flags |= (error << CLF_HSM_ERR_L);
749}
750
751#define CR_MAXSIZE cfs_size_round(2*NAME_MAX + 1 + \
752 sizeof(struct changelog_ext_rec))
753
754struct changelog_rec {
755 __u16 cr_namelen;
756 __u16 cr_flags;
757 __u32 cr_type;
758 __u64 cr_index;
759 __u64 cr_prev;
760 __u64 cr_time;
761 union {
762 struct lu_fid cr_tfid;
763 __u32 cr_markerflags;
764 };
765 struct lu_fid cr_pfid;
766 char cr_name[0];
767} __packed;
768
769
770
771
772
773struct changelog_ext_rec {
774 __u16 cr_namelen;
775 __u16 cr_flags;
776
777
778 __u32 cr_type;
779 __u64 cr_index;
780 __u64 cr_prev;
781 __u64 cr_time;
782 union {
783 struct lu_fid cr_tfid;
784 __u32 cr_markerflags;
785 };
786 struct lu_fid cr_pfid;
787 struct lu_fid cr_sfid;
788 struct lu_fid cr_spfid;
789 char cr_name[0];
790} __packed;
791
792#define CHANGELOG_REC_EXTENDED(rec) \
793 (((rec)->cr_flags & CLF_VERMASK) == CLF_EXT_VERSION)
794
795static inline int changelog_rec_size(struct changelog_rec *rec)
796{
797 return CHANGELOG_REC_EXTENDED(rec) ? sizeof(struct changelog_ext_rec) :
798 sizeof(*rec);
799}
800
801static inline char *changelog_rec_name(struct changelog_rec *rec)
802{
803 return CHANGELOG_REC_EXTENDED(rec) ?
804 ((struct changelog_ext_rec *)rec)->cr_name : rec->cr_name;
805}
806
807static inline int changelog_rec_snamelen(struct changelog_ext_rec *rec)
808{
809 return rec->cr_namelen - strlen(rec->cr_name) - 1;
810}
811
812static inline char *changelog_rec_sname(struct changelog_ext_rec *rec)
813{
814 return rec->cr_name + strlen(rec->cr_name) + 1;
815}
816
817struct ioc_changelog {
818 __u64 icc_recno;
819 __u32 icc_mdtindex;
820 __u32 icc_id;
821 __u32 icc_flags;
822};
823
824enum changelog_message_type {
825 CL_RECORD = 10,
826 CL_EOF = 11,
827};
828
829
830
831struct ioc_data_version {
832 __u64 idv_version;
833 __u64 idv_flags;
834};
835
836#define LL_DV_NOFLUSH 0x01
837
838
839
840#ifndef offsetof
841# define offsetof(typ, memb) ((unsigned long)((char *)&(((typ *)0)->memb)))
842#endif
843
844#define dot_lustre_name ".lustre"
845
846
847
848
849
850
851enum 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
862#define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
863
864
865#define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
866
867
868
869
870
871#define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK)
872
873
874
875
876enum hsm_progress_states {
877 HPS_WAITING = 1,
878 HPS_RUNNING = 2,
879 HPS_DONE = 3,
880};
881
882#define HPS_NONE 0
883
884static 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
894struct hsm_extent {
895 __u64 offset;
896 __u64 length;
897} __packed;
898
899
900
901
902
903
904
905struct hsm_user_state {
906
907 __u32 hus_states;
908 __u32 hus_archive_id;
909
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
916struct hsm_state_set_ioc {
917 struct lu_fid hssi_fid;
918 __u64 hssi_setmask;
919 __u64 hssi_clearmask;
920};
921
922
923
924
925
926struct hsm_current_action {
927
928
929 __u32 hca_state;
930
931 __u32 hca_action;
932 struct hsm_extent hca_location;
933};
934
935
936
937enum hsm_user_action {
938 HUA_NONE = 1,
939 HUA_ARCHIVE = 10,
940 HUA_RESTORE = 11,
941 HUA_RELEASE = 12,
942 HUA_REMOVE = 13,
943 HUA_CANCEL = 14
944};
945
946static 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
961
962#define HSM_FORCE_ACTION 0x0001
963
964#define HSM_GHOST_COPY 0x0002
965
966
967
968
969
970struct hsm_request {
971 __u32 hr_action;
972 __u32 hr_archive_id;
973 __u64 hr_flags;
974 __u32 hr_itemcount;
975 __u32 hr_data_len;
976};
977
978struct hsm_user_item {
979 struct lu_fid hui_fid;
980 struct hsm_extent hui_extent;
981} __packed;
982
983struct hsm_user_request {
984 struct hsm_request hur_request;
985 struct hsm_user_item hur_user_item[0];
986
987
988
989} __packed;
990
991
992static inline void *hur_data(struct hsm_user_request *hur)
993{
994 return &(hur->hur_user_item[hur->hur_request.hr_itemcount]);
995}
996
997
998
999
1000
1001
1002
1003static inline ssize_t hur_len(struct hsm_user_request *hur)
1004{
1005 __u64 size;
1006
1007
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;
1016}
1017
1018
1019
1020enum hsm_message_type {
1021 HMT_ACTION_LIST = 100,
1022};
1023
1024
1025enum hsm_copytool_action {
1026 HSMA_NONE = 10,
1027 HSMA_ARCHIVE = 20,
1028 HSMA_RESTORE = 21,
1029 HSMA_REMOVE = 22,
1030 HSMA_CANCEL = 23
1031};
1032
1033static 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
1046struct hsm_action_item {
1047 __u32 hai_len;
1048 __u32 hai_action;
1049 struct lu_fid hai_fid;
1050 struct lu_fid hai_dfid;
1051 struct hsm_extent hai_extent;
1052 __u64 hai_cookie;
1053 __u64 hai_gid;
1054 char hai_data[0];
1055} __packed;
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065static 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);
1074 for (i = 0 ; (i < data_len) && (sz > 0) ; i++) {
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
1087#define HAL_VERSION 1
1088#define HAL_MAXSIZE LNET_MTU
1089struct hsm_action_list {
1090 __u32 hal_version;
1091 __u32 hal_count;
1092 __u64 hal_compound_id;
1093 __u64 hal_flags;
1094 __u32 hal_archive_id;
1095 __u32 padding1;
1096 char hal_fsname[0];
1097
1098
1099
1100} __packed;
1101
1102#ifndef HAVE_CFS_SIZE_ROUND
1103static inline int cfs_size_round (int val)
1104{
1105 return (val + 7) & (~0x7);
1106}
1107
1108#define HAVE_CFS_SIZE_ROUND
1109#endif
1110
1111
1112static inline struct hsm_action_item *hai_zero(struct hsm_action_list *hal)
1113{
1114 return (struct hsm_action_item *)(hal->hal_fsname +
1115 cfs_size_round(strlen(hal-> \
1116 hal_fsname)
1117 + 1));
1118}
1119
1120
1121static inline struct hsm_action_item *hai_next(struct hsm_action_item *hai)
1122{
1123 return (struct hsm_action_item *)((char *)hai +
1124 cfs_size_round(hai->hai_len));
1125}
1126
1127
1128static inline int hal_size(struct hsm_action_list *hal)
1129{
1130 int i, sz;
1131 struct hsm_action_item *hai;
1132
1133 sz = sizeof(*hal) + cfs_size_round(strlen(hal->hal_fsname) + 1);
1134 hai = hai_zero(hal);
1135 for (i = 0; i < hal->hal_count; i++, hai = hai_next(hai))
1136 sz += cfs_size_round(hai->hai_len);
1137
1138 return sz;
1139}
1140
1141
1142
1143
1144struct 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
1156
1157#define HP_FLAG_COMPLETED 0x01
1158#define HP_FLAG_RETRY 0x02
1159
1160struct hsm_progress {
1161 struct lu_fid hp_fid;
1162 __u64 hp_cookie;
1163 struct hsm_extent hp_extent;
1164 __u16 hp_flags;
1165 __u16 hp_errval;
1166 __u32 padding;
1167};
1168
1169struct hsm_copy {
1170 __u64 hc_data_version;
1171 __u16 hc_flags;
1172 __u16 hc_errval;
1173 __u32 padding;
1174 struct hsm_action_item hc_hai;
1175};
1176
1177
1178
1179#endif
1180