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#ifndef _LUSTRE_USER_H
38#define _LUSTRE_USER_H
39
40
41
42
43
44
45#ifdef __KERNEL__
46# include <linux/fs.h>
47# include <linux/quota.h>
48# include <linux/sched/signal.h>
49# include <linux/string.h>
50# include <linux/version.h>
51#else
52# define NEED_QUOTA_DEFS
53# include <stdio.h>
54# include <string.h>
55# include <sys/quota.h>
56# include <sys/stat.h>
57#endif
58#include <uapi/linux/lustre/lustre_fiemap.h>
59
60
61
62
63
64
65#if __BITS_PER_LONG != 64 || defined(__ARCH_WANT_STAT64)
66typedef struct stat64 lstat_t;
67#define lstat_f lstat64
68#define fstat_f fstat64
69#define fstatat_f fstatat64
70#else
71typedef struct stat lstat_t;
72#define lstat_f lstat
73#define fstat_f fstat
74#define fstatat_f fstatat
75#endif
76
77#define HAVE_LOV_USER_MDS_DATA
78
79#define LUSTRE_EOF 0xffffffffffffffffULL
80
81
82#define LL_SUPER_MAGIC 0x0BD00BD0
83
84#ifndef FSFILT_IOC_GETFLAGS
85#define FSFILT_IOC_GETFLAGS _IOR('f', 1, long)
86#define FSFILT_IOC_SETFLAGS _IOW('f', 2, long)
87#define FSFILT_IOC_GETVERSION _IOR('f', 3, long)
88#define FSFILT_IOC_SETVERSION _IOW('f', 4, long)
89#define FSFILT_IOC_GETVERSION_OLD _IOR('v', 1, long)
90#define FSFILT_IOC_SETVERSION_OLD _IOW('v', 2, long)
91#endif
92
93
94#define LUSTRE_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_DEVICE_ORDER)
95
96enum obd_statfs_state {
97 OS_STATE_DEGRADED = 0x00000001,
98 OS_STATE_READONLY = 0x00000002,
99 OS_STATE_RDONLY_1 = 0x00000004,
100 OS_STATE_RDONLY_2 = 0x00000008,
101 OS_STATE_RDONLY_3 = 0x00000010,
102};
103
104struct obd_statfs {
105 __u64 os_type;
106 __u64 os_blocks;
107 __u64 os_bfree;
108 __u64 os_bavail;
109 __u64 os_files;
110 __u64 os_ffree;
111 __u8 os_fsid[40];
112 __u32 os_bsize;
113 __u32 os_namelen;
114 __u64 os_maxbytes;
115 __u32 os_state;
116 __u32 os_fprecreated;
117
118 __u32 os_spare2;
119 __u32 os_spare3;
120 __u32 os_spare4;
121 __u32 os_spare5;
122 __u32 os_spare6;
123 __u32 os_spare7;
124 __u32 os_spare8;
125 __u32 os_spare9;
126};
127
128
129
130
131
132
133
134struct lu_fid {
135
136
137
138
139
140
141 __u64 f_seq;
142
143 __u32 f_oid;
144
145
146
147
148
149 __u32 f_ver;
150};
151
152static inline bool fid_is_zero(const struct lu_fid *fid)
153{
154 return !fid->f_seq && !fid->f_oid;
155}
156
157struct filter_fid {
158 struct lu_fid ff_parent;
159};
160
161
162struct filter_fid_old {
163 struct lu_fid ff_parent;
164 __u64 ff_objid;
165 __u64 ff_seq;
166};
167
168
169
170
171
172struct lu_fid;
173
174
175
176
177
178
179struct lustre_mdt_attrs {
180
181
182
183
184 __u32 lma_compat;
185
186
187
188
189
190 __u32 lma_incompat;
191
192 struct lu_fid lma_self_fid;
193};
194
195
196
197
198
199
200#define LMA_OLD_SIZE (sizeof(struct lustre_mdt_attrs) + 5 * sizeof(__u64))
201
202
203
204
205struct ost_id {
206 union {
207 struct {
208 __u64 oi_id;
209 __u64 oi_seq;
210 } oi;
211 struct lu_fid oi_fid;
212 };
213};
214
215#define DOSTID "%#llx:%llu"
216#define POSTID(oi) ostid_seq(oi), ostid_id(oi)
217
218
219
220
221
222
223
224
225
226
227
228
229#define LL_IOC_GETFLAGS _IOR('f', 151, long)
230#define LL_IOC_SETFLAGS _IOW('f', 152, long)
231#define LL_IOC_CLRFLAGS _IOW('f', 153, long)
232#define LL_IOC_LOV_SETSTRIPE _IOW('f', 154, long)
233#define LL_IOC_LOV_GETSTRIPE _IOW('f', 155, long)
234#define LL_IOC_LOV_SETEA _IOW('f', 156, long)
235
236
237#define LL_IOC_GROUP_LOCK _IOW('f', 158, long)
238#define LL_IOC_GROUP_UNLOCK _IOW('f', 159, long)
239
240
241
242#define IOC_OBD_STATFS _IOWR('f', 164, struct obd_statfs *)
243
244#define LL_IOC_FLUSHCTX _IOW('f', 166, long)
245
246#define LL_IOC_GETOBDCOUNT _IOR('f', 168, long)
247#define LL_IOC_LLOOP_ATTACH _IOWR('f', 169, long)
248#define LL_IOC_LLOOP_DETACH _IOWR('f', 170, long)
249#define LL_IOC_LLOOP_INFO _IOWR('f', 171, struct lu_fid)
250#define LL_IOC_LLOOP_DETACH_BYDEV _IOWR('f', 172, long)
251#define LL_IOC_PATH2FID _IOR('f', 173, long)
252#define LL_IOC_GET_CONNECT_FLAGS _IOWR('f', 174, __u64 *)
253#define LL_IOC_GET_MDTIDX _IOR('f', 175, int)
254
255
256#define LL_IOC_HSM_STATE_GET _IOR('f', 211, struct hsm_user_state)
257#define LL_IOC_HSM_STATE_SET _IOW('f', 212, struct hsm_state_set)
258#define LL_IOC_HSM_CT_START _IOW('f', 213, struct lustre_kernelcomm)
259#define LL_IOC_HSM_COPY_START _IOW('f', 214, struct hsm_copy *)
260#define LL_IOC_HSM_COPY_END _IOW('f', 215, struct hsm_copy *)
261#define LL_IOC_HSM_PROGRESS _IOW('f', 216, struct hsm_user_request)
262#define LL_IOC_HSM_REQUEST _IOW('f', 217, struct hsm_user_request)
263#define LL_IOC_DATA_VERSION _IOR('f', 218, struct ioc_data_version)
264#define LL_IOC_LOV_SWAP_LAYOUTS _IOW('f', 219, \
265 struct lustre_swap_layouts)
266#define LL_IOC_HSM_ACTION _IOR('f', 220, \
267 struct hsm_current_action)
268
269
270#define LL_IOC_LMV_SETSTRIPE _IOWR('f', 240, struct lmv_user_md)
271#define LL_IOC_LMV_GETSTRIPE _IOWR('f', 241, struct lmv_user_md)
272#define LL_IOC_SET_LEASE _IOWR('f', 243, long)
273#define LL_IOC_GET_LEASE _IO('f', 244)
274#define LL_IOC_HSM_IMPORT _IOWR('f', 245, struct hsm_user_import)
275#define LL_IOC_LMV_SET_DEFAULT_STRIPE _IOWR('f', 246, struct lmv_user_md)
276#define LL_IOC_MIGRATE _IOR('f', 247, int)
277#define LL_IOC_FID2MDTIDX _IOWR('f', 248, struct lu_fid)
278#define LL_IOC_GETPARENT _IOWR('f', 249, struct getparent)
279
280
281enum ll_lease_type {
282 LL_LEASE_RDLCK = 0x1,
283 LL_LEASE_WRLCK = 0x2,
284 LL_LEASE_UNLCK = 0x4,
285};
286
287#define LL_STATFS_LMV 1
288#define LL_STATFS_LOV 2
289#define LL_STATFS_NODELAY 4
290
291#define IOC_MDC_TYPE 'i'
292#define IOC_MDC_LOOKUP _IOWR(IOC_MDC_TYPE, 20, struct obd_device *)
293#define IOC_MDC_GETFILESTRIPE _IOWR(IOC_MDC_TYPE, 21, struct lov_user_md *)
294#define IOC_MDC_GETFILEINFO _IOWR(IOC_MDC_TYPE, 22, struct lov_user_mds_data *)
295#define LL_IOC_MDC_GETINFO _IOWR(IOC_MDC_TYPE, 23, struct lov_user_mds_data *)
296
297#define MAX_OBD_NAME 128
298
299
300
301
302
303
304#define O_LOV_DELAY_CREATE (O_NOCTTY | FASYNC)
305
306#define LL_FILE_IGNORE_LOCK 0x00000001
307#define LL_FILE_GROUP_LOCKED 0x00000002
308#define LL_FILE_READAHEA 0x00000004
309#define LL_FILE_LOCKED_DIRECTIO 0x00000008
310#define LL_FILE_LOCKLESS_IO 0x00000010
311#define LL_FILE_RMTACL 0x00000020
312
313#define LOV_USER_MAGIC_V1 0x0BD10BD0
314#define LOV_USER_MAGIC LOV_USER_MAGIC_V1
315#define LOV_USER_MAGIC_JOIN_V1 0x0BD20BD0
316#define LOV_USER_MAGIC_V3 0x0BD30BD0
317
318#define LOV_USER_MAGIC_SPECIFIC 0x0BD50BD0
319
320#define LMV_USER_MAGIC 0x0CD30CD0
321
322#define LOV_PATTERN_RAID0 0x001
323#define LOV_PATTERN_RAID1 0x002
324#define LOV_PATTERN_FIRST 0x100
325#define LOV_PATTERN_CMOBD 0x200
326
327#define LOV_PATTERN_F_MASK 0xffff0000
328#define LOV_PATTERN_F_HOLE 0x40000000
329#define LOV_PATTERN_F_RELEASED 0x80000000
330
331#define LOV_MAXPOOLNAME 15
332#define LOV_POOLNAMEF "%.15s"
333
334#define LOV_MIN_STRIPE_BITS 16
335#define LOV_MIN_STRIPE_SIZE (1 << LOV_MIN_STRIPE_BITS)
336#define LOV_MAX_STRIPE_COUNT_OLD 160
337
338
339
340
341
342
343
344
345
346
347#define LOV_MAX_STRIPE_COUNT 2000
348#define LOV_ALL_STRIPES 0xffff
349#define LOV_V1_INSANE_STRIPE_COUNT 65532
350
351#define XATTR_LUSTRE_PREFIX "lustre."
352#define XATTR_LUSTRE_LOV "lustre.lov"
353
354#define lov_user_ost_data lov_user_ost_data_v1
355struct lov_user_ost_data_v1 {
356 struct ost_id l_ost_oi;
357 __u32 l_ost_gen;
358 __u32 l_ost_idx;
359} __packed;
360
361#define lov_user_md lov_user_md_v1
362struct lov_user_md_v1 {
363 __u32 lmm_magic;
364 __u32 lmm_pattern;
365 struct ost_id lmm_oi;
366 __u32 lmm_stripe_size;
367 __u16 lmm_stripe_count;
368 union {
369 __u16 lmm_stripe_offset;
370
371
372 __u16 lmm_layout_gen;
373
374
375 };
376 struct lov_user_ost_data_v1 lmm_objects[0];
377} __attribute__((packed, __may_alias__));
378
379struct lov_user_md_v3 {
380 __u32 lmm_magic;
381 __u32 lmm_pattern;
382 struct ost_id lmm_oi;
383 __u32 lmm_stripe_size;
384 __u16 lmm_stripe_count;
385 union {
386 __u16 lmm_stripe_offset;
387
388
389 __u16 lmm_layout_gen;
390
391
392 };
393 char lmm_pool_name[LOV_MAXPOOLNAME + 1];
394 struct lov_user_ost_data_v1 lmm_objects[0];
395} __packed;
396
397static inline __u32 lov_user_md_size(__u16 stripes, __u32 lmm_magic)
398{
399 if (lmm_magic == LOV_USER_MAGIC_V1)
400 return sizeof(struct lov_user_md_v1) +
401 stripes * sizeof(struct lov_user_ost_data_v1);
402 return sizeof(struct lov_user_md_v3) +
403 stripes * sizeof(struct lov_user_ost_data_v1);
404}
405
406
407
408
409#ifdef HAVE_LOV_USER_MDS_DATA
410#define lov_user_mds_data lov_user_mds_data_v1
411struct lov_user_mds_data_v1 {
412 lstat_t lmd_st;
413 struct lov_user_md_v1 lmd_lmm;
414} __packed;
415
416struct lov_user_mds_data_v3 {
417 lstat_t lmd_st;
418 struct lov_user_md_v3 lmd_lmm;
419} __packed;
420#endif
421
422struct lmv_user_mds_data {
423 struct lu_fid lum_fid;
424 __u32 lum_padding;
425 __u32 lum_mds;
426};
427
428enum lmv_hash_type {
429 LMV_HASH_TYPE_UNKNOWN = 0,
430 LMV_HASH_TYPE_ALL_CHARS = 1,
431 LMV_HASH_TYPE_FNV_1A_64 = 2,
432};
433
434#define LMV_HASH_NAME_ALL_CHARS "all_char"
435#define LMV_HASH_NAME_FNV_1A_64 "fnv_1a_64"
436
437
438
439
440
441#define LMV_MAX_STRIPE_COUNT 2000
442#define lmv_user_md lmv_user_md_v1
443struct lmv_user_md_v1 {
444 __u32 lum_magic;
445 __u32 lum_stripe_count;
446 __u32 lum_stripe_offset;
447 __u32 lum_hash_type;
448 __u32 lum_type;
449 __u32 lum_padding1;
450 __u32 lum_padding2;
451 __u32 lum_padding3;
452 char lum_pool_name[LOV_MAXPOOLNAME + 1];
453 struct lmv_user_mds_data lum_objects[0];
454} __packed;
455
456static inline int lmv_user_md_size(int stripes, int lmm_magic)
457{
458 return sizeof(struct lmv_user_md) +
459 stripes * sizeof(struct lmv_user_mds_data);
460}
461
462struct ll_recreate_obj {
463 __u64 lrc_id;
464 __u32 lrc_ost_idx;
465};
466
467struct ll_fid {
468 __u64 id;
469 __u32 generation;
470 __u32 f_type;
471
472};
473
474#define UUID_MAX 40
475struct obd_uuid {
476 char uuid[UUID_MAX];
477};
478
479static inline bool obd_uuid_equals(const struct obd_uuid *u1,
480 const struct obd_uuid *u2)
481{
482 return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
483}
484
485static inline int obd_uuid_empty(struct obd_uuid *uuid)
486{
487 return uuid->uuid[0] == '\0';
488}
489
490static inline void obd_str2uuid(struct obd_uuid *uuid, const char *tmp)
491{
492 strncpy((char *)uuid->uuid, tmp, sizeof(*uuid));
493 uuid->uuid[sizeof(*uuid) - 1] = '\0';
494}
495
496
497static inline char *obd_uuid2str(const struct obd_uuid *uuid)
498{
499 if (!uuid)
500 return NULL;
501
502 if (uuid->uuid[sizeof(*uuid) - 1] != '\0') {
503
504
505
506 static char temp[sizeof(*uuid)];
507
508 memcpy(temp, uuid->uuid, sizeof(*uuid) - 1);
509 temp[sizeof(*uuid) - 1] = '\0';
510 return temp;
511 }
512 return (char *)(uuid->uuid);
513}
514
515
516
517
518
519static inline void obd_uuid2fsname(char *buf, char *uuid, int buflen)
520{
521 char *p;
522
523 strncpy(buf, uuid, buflen - 1);
524 buf[buflen - 1] = '\0';
525 p = strrchr(buf, '-');
526 if (p)
527 *p = '\0';
528}
529
530
531
532
533#define FID_NOBRACE_LEN 40
534#define FID_LEN (FID_NOBRACE_LEN + 2)
535#define DFID_NOBRACE "%#llx:0x%x:0x%x"
536#define DFID "[" DFID_NOBRACE "]"
537#define PFID(fid) (unsigned long long)(fid)->f_seq, (fid)->f_oid, (fid)->f_ver
538
539
540
541
542
543#define SFID "0x%llx:0x%x:0x%x"
544#define RFID(fid) &((fid)->f_seq), &((fid)->f_oid), &((fid)->f_ver)
545
546
547
548#define Q_QUOTACHECK 0x800100
549#define Q_INITQUOTA 0x800101
550#define Q_GETOINFO 0x800102
551#define Q_GETOQUOTA 0x800103
552#define Q_FINVALIDATE 0x800104
553
554
555#define LUSTRE_Q_QUOTAON 0x800002
556#define LUSTRE_Q_QUOTAOFF 0x800003
557#define LUSTRE_Q_GETINFO 0x800005
558#define LUSTRE_Q_SETINFO 0x800006
559#define LUSTRE_Q_GETQUOTA 0x800007
560#define LUSTRE_Q_SETQUOTA 0x800008
561
562#define LUSTRE_Q_INVALIDATE 0x80000b
563#define LUSTRE_Q_FINVALIDATE 0x80000c
564
565#define UGQUOTA 2
566
567#define IDENTITY_DOWNCALL_MAGIC 0x6d6dd629
568
569
570#define N_PERMS_MAX 64
571
572struct perm_downcall_data {
573 __u64 pdd_nid;
574 __u32 pdd_perm;
575 __u32 pdd_padding;
576};
577
578struct identity_downcall_data {
579 __u32 idd_magic;
580 __u32 idd_err;
581 __u32 idd_uid;
582 __u32 idd_gid;
583 __u32 idd_nperms;
584 __u32 idd_ngroups;
585 struct perm_downcall_data idd_perms[N_PERMS_MAX];
586 __u32 idd_groups[0];
587};
588
589
590
591
592#define LUSTRE_VOLATILE_HDR ".\x0c\x13\x14\x12:VOLATILE"
593#define LUSTRE_VOLATILE_HDR_LEN 14
594
595#define LUSTRE_VOLATILE_IDX LUSTRE_VOLATILE_HDR":%.4X:"
596
597enum lustre_quota_version {
598 LUSTRE_QUOTA_V2 = 1
599};
600
601
602struct obd_dqinfo {
603 __u64 dqi_bgrace;
604 __u64 dqi_igrace;
605 __u32 dqi_flags;
606 __u32 dqi_valid;
607};
608
609
610struct obd_dqblk {
611 __u64 dqb_bhardlimit;
612 __u64 dqb_bsoftlimit;
613 __u64 dqb_curspace;
614 __u64 dqb_ihardlimit;
615 __u64 dqb_isoftlimit;
616 __u64 dqb_curinodes;
617 __u64 dqb_btime;
618 __u64 dqb_itime;
619 __u32 dqb_valid;
620 __u32 dqb_padding;
621};
622
623enum {
624 QC_GENERAL = 0,
625 QC_MDTIDX = 1,
626 QC_OSTIDX = 2,
627 QC_UUID = 3
628};
629
630struct if_quotactl {
631 __u32 qc_cmd;
632 __u32 qc_type;
633 __u32 qc_id;
634 __u32 qc_stat;
635 __u32 qc_valid;
636 __u32 qc_idx;
637 struct obd_dqinfo qc_dqinfo;
638 struct obd_dqblk qc_dqblk;
639 char obd_type[16];
640 struct obd_uuid obd_uuid;
641};
642
643
644#define SWAP_LAYOUTS_CHECK_DV1 (1 << 0)
645#define SWAP_LAYOUTS_CHECK_DV2 (1 << 1)
646#define SWAP_LAYOUTS_KEEP_MTIME (1 << 2)
647#define SWAP_LAYOUTS_KEEP_ATIME (1 << 3)
648#define SWAP_LAYOUTS_CLOSE (1 << 4)
649
650
651#define SWAP_LAYOUTS_MDS_HSM (1 << 31)
652struct lustre_swap_layouts {
653 __u64 sl_flags;
654 __u32 sl_fd;
655 __u32 sl_gid;
656 __u64 sl_dv1;
657 __u64 sl_dv2;
658};
659
660
661
662enum changelog_rec_type {
663 CL_MARK = 0,
664 CL_CREATE = 1,
665 CL_MKDIR = 2,
666 CL_HARDLINK = 3,
667 CL_SOFTLINK = 4,
668 CL_MKNOD = 5,
669 CL_UNLINK = 6,
670 CL_RMDIR = 7,
671 CL_RENAME = 8,
672 CL_EXT = 9,
673 CL_OPEN = 10,
674 CL_CLOSE = 11,
675 CL_LAYOUT = 12,
676 CL_TRUNC = 13,
677 CL_SETATTR = 14,
678 CL_XATTR = 15,
679 CL_HSM = 16,
680 CL_MTIME = 17,
681 CL_CTIME = 18,
682 CL_ATIME = 19,
683 CL_LAST
684};
685
686static inline const char *changelog_type2str(int type)
687{
688 static const char *changelog_str[] = {
689 "MARK", "CREAT", "MKDIR", "HLINK", "SLINK", "MKNOD", "UNLNK",
690 "RMDIR", "RENME", "RNMTO", "OPEN", "CLOSE", "LYOUT", "TRUNC",
691 "SATTR", "XATTR", "HSM", "MTIME", "CTIME", "ATIME",
692 };
693
694 if (type >= 0 && type < CL_LAST)
695 return changelog_str[type];
696 return NULL;
697}
698
699
700#define CLF_FLAGSHIFT 12
701#define CLF_FLAGMASK ((1U << CLF_FLAGSHIFT) - 1)
702#define CLF_VERMASK (~CLF_FLAGMASK)
703enum changelog_rec_flags {
704 CLF_VERSION = 0x1000,
705 CLF_RENAME = 0x2000,
706 CLF_JOBID = 0x4000,
707 CLF_SUPPORTED = CLF_VERSION | CLF_RENAME | CLF_JOBID
708};
709
710
711
712#define CLF_UNLINK_LAST 0x0001
713#define CLF_UNLINK_HSM_EXISTS 0x0002
714
715
716#define CLF_RENAME_LAST 0x0001
717
718
719#define CLF_RENAME_LAST_EXISTS 0x0002
720
721
722
723
724
725
726
727
728
729#define CLF_HSM_ERR_L 0
730#define CLF_HSM_ERR_H 6
731#define CLF_HSM_EVENT_L 7
732#define CLF_HSM_EVENT_H 9
733#define CLF_HSM_FLAG_L 10
734#define CLF_HSM_FLAG_H 11
735#define CLF_HSM_SPARE_L 12
736#define CLF_HSM_SPARE_H 15
737#define CLF_HSM_LAST 15
738
739
740
741
742#define CLF_GET_BITS(_b, _h, _l) (((_b << (CLF_HSM_LAST - _h)) & 0xFFFF) \
743 >> (CLF_HSM_LAST - _h + _l))
744
745#define CLF_HSM_SUCCESS 0x00
746#define CLF_HSM_MAXERROR 0x7E
747#define CLF_HSM_ERROVERFLOW 0x7F
748
749#define CLF_HSM_DIRTY 1
750
751
752enum hsm_event {
753 HE_ARCHIVE = 0,
754 HE_RESTORE = 1,
755 HE_CANCEL = 2,
756 HE_RELEASE = 3,
757 HE_REMOVE = 4,
758 HE_STATE = 5,
759 HE_SPARE1 = 6,
760 HE_SPARE2 = 7,
761};
762
763static inline enum hsm_event hsm_get_cl_event(__u16 flags)
764{
765 return CLF_GET_BITS(flags, CLF_HSM_EVENT_H, CLF_HSM_EVENT_L);
766}
767
768static inline void hsm_set_cl_event(int *flags, enum hsm_event he)
769{
770 *flags |= (he << CLF_HSM_EVENT_L);
771}
772
773static inline __u16 hsm_get_cl_flags(int flags)
774{
775 return CLF_GET_BITS(flags, CLF_HSM_FLAG_H, CLF_HSM_FLAG_L);
776}
777
778static inline void hsm_set_cl_flags(int *flags, int bits)
779{
780 *flags |= (bits << CLF_HSM_FLAG_L);
781}
782
783static inline int hsm_get_cl_error(int flags)
784{
785 return CLF_GET_BITS(flags, CLF_HSM_ERR_H, CLF_HSM_ERR_L);
786}
787
788static inline void hsm_set_cl_error(int *flags, int error)
789{
790 *flags |= (error << CLF_HSM_ERR_L);
791}
792
793enum changelog_send_flag {
794
795 CHANGELOG_FLAG_FOLLOW = 0x01,
796
797
798
799
800
801 CHANGELOG_FLAG_BLOCK = 0x02,
802
803 CHANGELOG_FLAG_JOBID = 0x04,
804};
805
806#define CR_MAXSIZE cfs_size_round(2 * NAME_MAX + 2 + \
807 changelog_rec_offset(CLF_SUPPORTED))
808
809
810#define LUSTRE_JOBID_SIZE 32
811
812
813
814
815
816
817
818
819struct changelog_rec {
820 __u16 cr_namelen;
821 __u16 cr_flags;
822 __u32 cr_type;
823 __u64 cr_index;
824 __u64 cr_prev;
825 __u64 cr_time;
826 union {
827 struct lu_fid cr_tfid;
828 __u32 cr_markerflags;
829 };
830 struct lu_fid cr_pfid;
831} __packed;
832
833
834struct changelog_ext_rename {
835 struct lu_fid cr_sfid;
836 struct lu_fid cr_spfid;
837};
838
839
840struct changelog_ext_jobid {
841 char cr_jobid[LUSTRE_JOBID_SIZE];
842};
843
844static inline size_t changelog_rec_offset(enum changelog_rec_flags crf)
845{
846 size_t size = sizeof(struct changelog_rec);
847
848 if (crf & CLF_RENAME)
849 size += sizeof(struct changelog_ext_rename);
850
851 if (crf & CLF_JOBID)
852 size += sizeof(struct changelog_ext_jobid);
853
854 return size;
855}
856
857static inline size_t changelog_rec_size(struct changelog_rec *rec)
858{
859 return changelog_rec_offset(rec->cr_flags);
860}
861
862static inline size_t changelog_rec_varsize(struct changelog_rec *rec)
863{
864 return changelog_rec_size(rec) - sizeof(*rec) + rec->cr_namelen;
865}
866
867static inline
868struct changelog_ext_rename *changelog_rec_rename(struct changelog_rec *rec)
869{
870 enum changelog_rec_flags crf = rec->cr_flags & CLF_VERSION;
871
872 return (struct changelog_ext_rename *)((char *)rec +
873 changelog_rec_offset(crf));
874}
875
876
877static inline
878struct changelog_ext_jobid *changelog_rec_jobid(struct changelog_rec *rec)
879{
880 enum changelog_rec_flags crf = rec->cr_flags &
881 (CLF_VERSION | CLF_RENAME);
882
883 return (struct changelog_ext_jobid *)((char *)rec +
884 changelog_rec_offset(crf));
885}
886
887
888static inline char *changelog_rec_name(struct changelog_rec *rec)
889{
890 return (char *)rec + changelog_rec_offset(rec->cr_flags &
891 CLF_SUPPORTED);
892}
893
894static inline size_t changelog_rec_snamelen(struct changelog_rec *rec)
895{
896 return rec->cr_namelen - strlen(changelog_rec_name(rec)) - 1;
897}
898
899static inline char *changelog_rec_sname(struct changelog_rec *rec)
900{
901 char *cr_name = changelog_rec_name(rec);
902
903 return cr_name + strlen(cr_name) + 1;
904}
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925static inline void changelog_remap_rec(struct changelog_rec *rec,
926 enum changelog_rec_flags crf_wanted)
927{
928 char *jid_mov, *rnm_mov;
929
930 crf_wanted &= CLF_SUPPORTED;
931
932 if ((rec->cr_flags & CLF_SUPPORTED) == crf_wanted)
933 return;
934
935
936 memmove((char *)rec + changelog_rec_offset(crf_wanted),
937 changelog_rec_name(rec), rec->cr_namelen);
938
939
940 jid_mov = (char *)rec +
941 changelog_rec_offset(crf_wanted & ~CLF_JOBID);
942 rnm_mov = (char *)rec +
943 changelog_rec_offset(crf_wanted & ~(CLF_JOBID | CLF_RENAME));
944
945
946 if ((crf_wanted & CLF_JOBID) && (rec->cr_flags & CLF_JOBID))
947 memmove(jid_mov, changelog_rec_jobid(rec),
948 sizeof(struct changelog_ext_jobid));
949
950 if ((crf_wanted & CLF_RENAME) && (rec->cr_flags & CLF_RENAME))
951 memmove(rnm_mov, changelog_rec_rename(rec),
952 sizeof(struct changelog_ext_rename));
953
954
955 if ((crf_wanted & CLF_JOBID) && !(rec->cr_flags & CLF_JOBID))
956 memset(jid_mov, 0, sizeof(struct changelog_ext_jobid));
957
958 if ((crf_wanted & CLF_RENAME) && !(rec->cr_flags & CLF_RENAME))
959 memset(rnm_mov, 0, sizeof(struct changelog_ext_rename));
960
961
962 rec->cr_flags = (rec->cr_flags & CLF_FLAGMASK) | crf_wanted;
963}
964
965struct ioc_changelog {
966 __u64 icc_recno;
967 __u32 icc_mdtindex;
968 __u32 icc_id;
969 __u32 icc_flags;
970};
971
972enum changelog_message_type {
973 CL_RECORD = 10,
974 CL_EOF = 11,
975};
976
977
978
979struct ioc_data_version {
980 __u64 idv_version;
981 __u64 idv_flags;
982};
983
984#define LL_DV_RD_FLUSH (1 << 0)
985#define LL_DV_WR_FLUSH (1 << 1)
986
987#ifndef offsetof
988# define offsetof(typ, memb) ((unsigned long)((char *)&(((typ *)0)->memb)))
989#endif
990
991#define dot_lustre_name ".lustre"
992
993
994
995
996
997
998enum hsm_states {
999 HS_NONE = 0x00000000,
1000 HS_EXISTS = 0x00000001,
1001 HS_DIRTY = 0x00000002,
1002 HS_RELEASED = 0x00000004,
1003 HS_ARCHIVED = 0x00000008,
1004 HS_NORELEASE = 0x00000010,
1005 HS_NOARCHIVE = 0x00000020,
1006 HS_LOST = 0x00000040,
1007};
1008
1009
1010#define HSM_USER_MASK (HS_NORELEASE | HS_NOARCHIVE | HS_DIRTY)
1011
1012
1013#define HSM_STATUS_MASK (HS_EXISTS | HS_LOST | HS_RELEASED | HS_ARCHIVED)
1014
1015
1016
1017
1018
1019#define HSM_FLAGS_MASK (HSM_USER_MASK | HSM_STATUS_MASK)
1020
1021
1022
1023
1024enum hsm_progress_states {
1025 HPS_WAITING = 1,
1026 HPS_RUNNING = 2,
1027 HPS_DONE = 3,
1028};
1029
1030#define HPS_NONE 0
1031
1032static inline char *hsm_progress_state2name(enum hsm_progress_states s)
1033{
1034 switch (s) {
1035 case HPS_WAITING: return "waiting";
1036 case HPS_RUNNING: return "running";
1037 case HPS_DONE: return "done";
1038 default: return "unknown";
1039 }
1040}
1041
1042struct hsm_extent {
1043 __u64 offset;
1044 __u64 length;
1045} __packed;
1046
1047
1048
1049
1050
1051
1052
1053struct hsm_user_state {
1054
1055 __u32 hus_states;
1056 __u32 hus_archive_id;
1057
1058 __u32 hus_in_progress_state;
1059 __u32 hus_in_progress_action;
1060 struct hsm_extent hus_in_progress_location;
1061 char hus_extended_info[];
1062};
1063
1064struct hsm_state_set_ioc {
1065 struct lu_fid hssi_fid;
1066 __u64 hssi_setmask;
1067 __u64 hssi_clearmask;
1068};
1069
1070
1071
1072
1073
1074struct hsm_current_action {
1075
1076
1077 __u32 hca_state;
1078
1079 __u32 hca_action;
1080 struct hsm_extent hca_location;
1081};
1082
1083
1084
1085enum hsm_user_action {
1086 HUA_NONE = 1,
1087 HUA_ARCHIVE = 10,
1088 HUA_RESTORE = 11,
1089 HUA_RELEASE = 12,
1090 HUA_REMOVE = 13,
1091 HUA_CANCEL = 14
1092};
1093
1094static inline char *hsm_user_action2name(enum hsm_user_action a)
1095{
1096 switch (a) {
1097 case HUA_NONE: return "NOOP";
1098 case HUA_ARCHIVE: return "ARCHIVE";
1099 case HUA_RESTORE: return "RESTORE";
1100 case HUA_RELEASE: return "RELEASE";
1101 case HUA_REMOVE: return "REMOVE";
1102 case HUA_CANCEL: return "CANCEL";
1103 default: return "UNKNOWN";
1104 }
1105}
1106
1107
1108
1109
1110#define HSM_FORCE_ACTION 0x0001
1111
1112#define HSM_GHOST_COPY 0x0002
1113
1114
1115
1116
1117
1118struct hsm_request {
1119 __u32 hr_action;
1120 __u32 hr_archive_id;
1121 __u64 hr_flags;
1122 __u32 hr_itemcount;
1123 __u32 hr_data_len;
1124};
1125
1126struct hsm_user_item {
1127 struct lu_fid hui_fid;
1128 struct hsm_extent hui_extent;
1129} __packed;
1130
1131struct hsm_user_request {
1132 struct hsm_request hur_request;
1133 struct hsm_user_item hur_user_item[0];
1134
1135
1136
1137} __packed;
1138
1139
1140static inline void *hur_data(struct hsm_user_request *hur)
1141{
1142 return &hur->hur_user_item[hur->hur_request.hr_itemcount];
1143}
1144
1145
1146
1147
1148
1149
1150
1151static inline ssize_t hur_len(struct hsm_user_request *hur)
1152{
1153 __u64 size;
1154
1155
1156 size = offsetof(struct hsm_user_request, hur_user_item[0]) +
1157 (__u64)hur->hur_request.hr_itemcount *
1158 sizeof(hur->hur_user_item[0]) + hur->hur_request.hr_data_len;
1159
1160 if (size != (ssize_t)size)
1161 return -1;
1162
1163 return size;
1164}
1165
1166
1167
1168enum hsm_message_type {
1169 HMT_ACTION_LIST = 100,
1170};
1171
1172
1173enum hsm_copytool_action {
1174 HSMA_NONE = 10,
1175 HSMA_ARCHIVE = 20,
1176 HSMA_RESTORE = 21,
1177 HSMA_REMOVE = 22,
1178 HSMA_CANCEL = 23
1179};
1180
1181static inline char *hsm_copytool_action2name(enum hsm_copytool_action a)
1182{
1183 switch (a) {
1184 case HSMA_NONE: return "NOOP";
1185 case HSMA_ARCHIVE: return "ARCHIVE";
1186 case HSMA_RESTORE: return "RESTORE";
1187 case HSMA_REMOVE: return "REMOVE";
1188 case HSMA_CANCEL: return "CANCEL";
1189 default: return "UNKNOWN";
1190 }
1191}
1192
1193
1194struct hsm_action_item {
1195 __u32 hai_len;
1196 __u32 hai_action;
1197 struct lu_fid hai_fid;
1198 struct lu_fid hai_dfid;
1199 struct hsm_extent hai_extent;
1200 __u64 hai_cookie;
1201 __u64 hai_gid;
1202 char hai_data[0];
1203} __packed;
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213static inline char *hai_dump_data_field(struct hsm_action_item *hai,
1214 char *buffer, size_t len)
1215{
1216 int i, data_len;
1217 char *ptr;
1218
1219 ptr = buffer;
1220 data_len = hai->hai_len - sizeof(*hai);
1221 for (i = 0; (i < data_len) && (len > 2); i++) {
1222 snprintf(ptr, 3, "%02X", (unsigned char)hai->hai_data[i]);
1223 ptr += 2;
1224 len -= 2;
1225 }
1226
1227 *ptr = '\0';
1228
1229 return buffer;
1230}
1231
1232
1233#define HAL_VERSION 1
1234#define HAL_MAXSIZE LNET_MTU
1235struct hsm_action_list {
1236 __u32 hal_version;
1237 __u32 hal_count;
1238 __u64 hal_compound_id;
1239 __u64 hal_flags;
1240 __u32 hal_archive_id;
1241 __u32 padding1;
1242 char hal_fsname[0];
1243
1244
1245
1246} __packed;
1247
1248#ifndef HAVE_CFS_SIZE_ROUND
1249static inline int cfs_size_round(int val)
1250{
1251 return (val + 7) & (~0x7);
1252}
1253
1254#define HAVE_CFS_SIZE_ROUND
1255#endif
1256
1257
1258static inline struct hsm_action_item *hai_first(struct hsm_action_list *hal)
1259{
1260 return (struct hsm_action_item *)(hal->hal_fsname +
1261 cfs_size_round(strlen(hal-> \
1262 hal_fsname)
1263 + 1));
1264}
1265
1266
1267static inline struct hsm_action_item *hai_next(struct hsm_action_item *hai)
1268{
1269 return (struct hsm_action_item *)((char *)hai +
1270 cfs_size_round(hai->hai_len));
1271}
1272
1273
1274static inline int hal_size(struct hsm_action_list *hal)
1275{
1276 int i, sz;
1277 struct hsm_action_item *hai;
1278
1279 sz = sizeof(*hal) + cfs_size_round(strlen(hal->hal_fsname) + 1);
1280 hai = hai_first(hal);
1281 for (i = 0; i < hal->hal_count; i++, hai = hai_next(hai))
1282 sz += cfs_size_round(hai->hai_len);
1283
1284 return sz;
1285}
1286
1287
1288
1289
1290struct hsm_user_import {
1291 __u64 hui_size;
1292 __u64 hui_atime;
1293 __u64 hui_mtime;
1294 __u32 hui_atime_ns;
1295 __u32 hui_mtime_ns;
1296 __u32 hui_uid;
1297 __u32 hui_gid;
1298 __u32 hui_mode;
1299 __u32 hui_archive_id;
1300};
1301
1302
1303#define HP_FLAG_COMPLETED 0x01
1304#define HP_FLAG_RETRY 0x02
1305
1306struct hsm_progress {
1307 struct lu_fid hp_fid;
1308 __u64 hp_cookie;
1309 struct hsm_extent hp_extent;
1310 __u16 hp_flags;
1311 __u16 hp_errval;
1312 __u32 padding;
1313};
1314
1315struct hsm_copy {
1316 __u64 hc_data_version;
1317 __u16 hc_flags;
1318 __u16 hc_errval;
1319 __u32 padding;
1320 struct hsm_action_item hc_hai;
1321};
1322
1323
1324
1325#endif
1326