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#ifndef __LUSTRE_LU_OBJECT_H
34#define __LUSTRE_LU_OBJECT_H
35
36#include <stdarg.h>
37#include <linux/percpu_counter.h>
38#include "../../include/linux/libcfs/libcfs.h"
39#include "lustre/lustre_idl.h"
40#include "lu_ref.h"
41
42struct seq_file;
43struct lustre_cfg;
44struct lprocfs_stats;
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95struct lu_site;
96struct lu_object;
97struct lu_device;
98struct lu_object_header;
99struct lu_context;
100struct lu_env;
101
102
103
104
105struct lu_device_operations {
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138 struct lu_object *(*ldo_object_alloc)(const struct lu_env *env,
139 const struct lu_object_header *h,
140 struct lu_device *d);
141
142
143
144 int (*ldo_process_config)(const struct lu_env *env,
145 struct lu_device *, struct lustre_cfg *);
146 int (*ldo_recovery_complete)(const struct lu_env *,
147 struct lu_device *);
148
149
150
151
152
153
154
155 int (*ldo_prepare)(const struct lu_env *,
156 struct lu_device *parent,
157 struct lu_device *dev);
158
159};
160
161
162
163
164enum loc_flags {
165
166
167
168 LOC_F_NEW = 0x00000001,
169};
170
171
172
173
174
175
176struct lu_object_conf {
177
178
179
180 enum loc_flags loc_flags;
181};
182
183
184
185
186
187
188
189
190typedef int (*lu_printer_t)(const struct lu_env *env,
191 void *cookie, const char *format, ...)
192 __printf(3, 4);
193
194
195
196
197struct lu_object_operations {
198
199
200
201
202
203
204
205
206
207 int (*loo_object_init)(const struct lu_env *env,
208 struct lu_object *o,
209 const struct lu_object_conf *conf);
210
211
212
213
214
215 int (*loo_object_start)(const struct lu_env *env,
216 struct lu_object *o);
217
218
219
220
221
222 void (*loo_object_delete)(const struct lu_env *env,
223 struct lu_object *o);
224
225
226
227
228 void (*loo_object_free)(const struct lu_env *env,
229 struct lu_object *o);
230
231
232
233
234 void (*loo_object_release)(const struct lu_env *env,
235 struct lu_object *o);
236
237
238
239 int (*loo_object_print)(const struct lu_env *env, void *cookie,
240 lu_printer_t p, const struct lu_object *o);
241
242
243
244
245 int (*loo_object_invariant)(const struct lu_object *o);
246};
247
248
249
250
251struct lu_device_type;
252
253
254
255
256struct lu_device {
257
258
259
260
261
262
263 atomic_t ld_ref;
264
265
266
267 struct lu_device_type *ld_type;
268
269
270
271 const struct lu_device_operations *ld_ops;
272
273
274
275 struct lu_site *ld_site;
276
277
278 struct obd_device *ld_obd;
279
280
281
282 struct lu_ref ld_reference;
283
284
285
286 struct list_head ld_linkage;
287};
288
289struct lu_device_type_operations;
290
291
292
293
294
295enum lu_device_tag {
296
297 LU_DEVICE_MD = (1 << 0),
298
299 LU_DEVICE_DT = (1 << 1),
300
301 LU_DEVICE_CL = (1 << 2)
302};
303
304
305
306
307struct lu_device_type {
308
309
310
311 __u32 ldt_tags;
312
313
314
315 char *ldt_name;
316
317
318
319 const struct lu_device_type_operations *ldt_ops;
320
321
322
323 struct obd_type *ldt_obd_type;
324
325
326
327 __u32 ldt_ctx_tags;
328
329
330
331 atomic_t ldt_device_nr;
332
333
334
335
336
337 struct list_head ldt_linkage;
338};
339
340
341
342
343struct lu_device_type_operations {
344
345
346
347 struct lu_device *(*ldto_device_alloc)(const struct lu_env *env,
348 struct lu_device_type *t,
349 struct lustre_cfg *lcfg);
350
351
352
353
354
355 struct lu_device *(*ldto_device_free)(const struct lu_env *,
356 struct lu_device *);
357
358
359
360
361 int (*ldto_device_init)(const struct lu_env *env,
362 struct lu_device *, const char *,
363 struct lu_device *);
364
365
366
367
368
369 struct lu_device *(*ldto_device_fini)(const struct lu_env *env,
370 struct lu_device *);
371
372
373
374 int (*ldto_init)(struct lu_device_type *t);
375
376
377
378
379 void (*ldto_fini)(struct lu_device_type *t);
380
381
382
383 void (*ldto_start)(struct lu_device_type *t);
384
385
386
387 void (*ldto_stop)(struct lu_device_type *t);
388};
389
390static inline int lu_device_is_md(const struct lu_device *d)
391{
392 return ergo(d, d->ld_type->ldt_tags & LU_DEVICE_MD);
393}
394
395
396
397
398struct lu_attr {
399
400 __u64 la_size;
401
402 s64 la_mtime;
403
404 s64 la_atime;
405
406 s64 la_ctime;
407
408 __u64 la_blocks;
409
410 __u32 la_mode;
411
412 __u32 la_uid;
413
414 __u32 la_gid;
415
416 __u32 la_flags;
417
418 __u32 la_nlink;
419
420 __u32 la_blkbits;
421
422 __u32 la_blksize;
423
424 __u32 la_rdev;
425
426
427
428
429
430 __u64 la_valid;
431};
432
433
434enum la_valid {
435 LA_ATIME = 1 << 0,
436 LA_MTIME = 1 << 1,
437 LA_CTIME = 1 << 2,
438 LA_SIZE = 1 << 3,
439 LA_MODE = 1 << 4,
440 LA_UID = 1 << 5,
441 LA_GID = 1 << 6,
442 LA_BLOCKS = 1 << 7,
443 LA_TYPE = 1 << 8,
444 LA_FLAGS = 1 << 9,
445 LA_NLINK = 1 << 10,
446 LA_RDEV = 1 << 11,
447 LA_BLKSIZE = 1 << 12,
448 LA_KILL_SUID = 1 << 13,
449 LA_KILL_SGID = 1 << 14,
450};
451
452
453
454
455struct lu_object {
456
457
458
459 struct lu_object_header *lo_header;
460
461
462
463 struct lu_device *lo_dev;
464
465
466
467 const struct lu_object_operations *lo_ops;
468
469
470
471 struct list_head lo_linkage;
472
473
474
475 struct lu_ref_link lo_dev_ref;
476};
477
478enum lu_object_header_flags {
479
480
481
482
483
484 LU_OBJECT_HEARD_BANSHEE = 0,
485
486
487
488 LU_OBJECT_UNHASHED = 1,
489};
490
491enum lu_object_header_attr {
492 LOHA_EXISTS = 1 << 0,
493 LOHA_REMOTE = 1 << 1,
494
495
496
497 LOHA_FT_START = 001 << 12,
498 LOHA_FT_END = 017 << 12,
499};
500
501
502
503
504
505
506
507
508
509
510
511
512struct lu_object_header {
513
514
515
516 struct lu_fid loh_fid;
517
518
519
520
521 unsigned long loh_flags;
522
523
524
525 atomic_t loh_ref;
526
527
528
529
530 __u32 loh_attr;
531
532
533
534 struct hlist_node loh_hash;
535
536
537
538 struct list_head loh_lru;
539
540
541
542
543 struct list_head loh_layers;
544
545
546
547 struct lu_ref loh_reference;
548};
549
550struct fld;
551
552struct lu_site_bkt_data {
553
554
555
556 long lsb_lru_len;
557
558
559
560
561
562
563
564
565 struct list_head lsb_lru;
566
567
568
569
570
571
572
573
574 wait_queue_head_t lsb_marche_funebre;
575};
576
577enum {
578 LU_SS_CREATED = 0,
579 LU_SS_CACHE_HIT,
580 LU_SS_CACHE_MISS,
581 LU_SS_CACHE_RACE,
582 LU_SS_CACHE_DEATH_RACE,
583 LU_SS_LRU_PURGED,
584 LU_SS_LAST_STAT
585};
586
587
588
589
590
591
592
593
594
595
596
597struct lu_site {
598
599
600
601 struct cfs_hash *ls_obj_hash;
602
603
604
605 unsigned int ls_purge_start;
606
607
608
609 struct lu_device *ls_top_dev;
610
611
612
613 struct lu_device *ls_bottom_dev;
614
615
616
617 struct list_head ls_linkage;
618
619
620
621
622 struct list_head ls_ld_linkage;
623 spinlock_t ls_ld_lock;
624
625
626
627
628 struct mutex ls_purge_mutex;
629
630
631
632
633 struct lprocfs_stats *ls_stats;
634
635
636
637 struct seq_server_site *ld_seq_site;
638
639
640
641 struct percpu_counter ls_lru_len_counter;
642};
643
644static inline struct lu_site_bkt_data *
645lu_site_bkt_from_fid(struct lu_site *site, struct lu_fid *fid)
646{
647 struct cfs_hash_bd bd;
648
649 cfs_hash_bd_get(site->ls_obj_hash, fid, &bd);
650 return cfs_hash_bd_extra_get(site->ls_obj_hash, &bd);
651}
652
653static inline struct seq_server_site *lu_site2seq(const struct lu_site *s)
654{
655 return s->ld_seq_site;
656}
657
658
659
660
661
662
663int lu_site_init(struct lu_site *s, struct lu_device *d);
664void lu_site_fini(struct lu_site *s);
665int lu_site_init_finish(struct lu_site *s);
666void lu_stack_fini(const struct lu_env *env, struct lu_device *top);
667void lu_device_get(struct lu_device *d);
668void lu_device_put(struct lu_device *d);
669int lu_device_init(struct lu_device *d, struct lu_device_type *t);
670void lu_device_fini(struct lu_device *d);
671int lu_object_header_init(struct lu_object_header *h);
672void lu_object_header_fini(struct lu_object_header *h);
673int lu_object_init(struct lu_object *o,
674 struct lu_object_header *h, struct lu_device *d);
675void lu_object_fini(struct lu_object *o);
676void lu_object_add_top(struct lu_object_header *h, struct lu_object *o);
677void lu_object_add(struct lu_object *before, struct lu_object *o);
678
679
680
681
682
683int lu_device_type_init(struct lu_device_type *ldt);
684void lu_device_type_fini(struct lu_device_type *ldt);
685
686
687
688
689
690
691
692
693
694
695
696
697
698static inline void lu_object_get(struct lu_object *o)
699{
700 LASSERT(atomic_read(&o->lo_header->loh_ref) > 0);
701 atomic_inc(&o->lo_header->loh_ref);
702}
703
704
705
706
707
708static inline int lu_object_is_dying(const struct lu_object_header *h)
709{
710 return test_bit(LU_OBJECT_HEARD_BANSHEE, &h->loh_flags);
711}
712
713void lu_object_put(const struct lu_env *env, struct lu_object *o);
714void lu_object_unhash(const struct lu_env *env, struct lu_object *o);
715int lu_site_purge_objects(const struct lu_env *env, struct lu_site *s, int nr,
716 bool canblock);
717
718static inline int lu_site_purge(const struct lu_env *env, struct lu_site *s,
719 int nr)
720{
721 return lu_site_purge_objects(env, s, nr, true);
722}
723
724void lu_site_print(const struct lu_env *env, struct lu_site *s, void *cookie,
725 lu_printer_t printer);
726struct lu_object *lu_object_find_at(const struct lu_env *env,
727 struct lu_device *dev,
728 const struct lu_fid *f,
729 const struct lu_object_conf *conf);
730struct lu_object *lu_object_find_slice(const struct lu_env *env,
731 struct lu_device *dev,
732 const struct lu_fid *f,
733 const struct lu_object_conf *conf);
734
735
736
737
738
739
740
741
742
743
744static inline struct lu_object *lu_object_top(struct lu_object_header *h)
745{
746 LASSERT(!list_empty(&h->loh_layers));
747 return container_of0(h->loh_layers.next, struct lu_object, lo_linkage);
748}
749
750
751
752
753static inline struct lu_object *lu_object_next(const struct lu_object *o)
754{
755 return container_of0(o->lo_linkage.next, struct lu_object, lo_linkage);
756}
757
758
759
760
761static inline const struct lu_fid *lu_object_fid(const struct lu_object *o)
762{
763 return &o->lo_header->loh_fid;
764}
765
766
767
768
769static inline const struct lu_device_operations *
770lu_object_ops(const struct lu_object *o)
771{
772 return o->lo_dev->ld_ops;
773}
774
775
776
777
778
779struct lu_object *lu_object_locate(struct lu_object_header *h,
780 const struct lu_device_type *dtype);
781
782
783
784
785int lu_cdebug_printer(const struct lu_env *env,
786 void *cookie, const char *format, ...);
787
788
789
790
791#define LU_OBJECT_DEBUG(mask, env, object, format, ...) \
792do { \
793 if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \
794 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \
795 lu_object_print(env, &msgdata, lu_cdebug_printer, object);\
796 CDEBUG(mask, format "\n", ## __VA_ARGS__); \
797 } \
798} while (0)
799
800
801
802
803#define LU_OBJECT_HEADER(mask, env, object, format, ...) \
804do { \
805 if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \
806 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \
807 lu_object_header_print(env, &msgdata, lu_cdebug_printer,\
808 (object)->lo_header); \
809 lu_cdebug_printer(env, &msgdata, "\n"); \
810 CDEBUG(mask, format, ## __VA_ARGS__); \
811 } \
812} while (0)
813
814void lu_object_print (const struct lu_env *env, void *cookie,
815 lu_printer_t printer, const struct lu_object *o);
816void lu_object_header_print(const struct lu_env *env, void *cookie,
817 lu_printer_t printer,
818 const struct lu_object_header *hdr);
819
820
821
822
823int lu_object_invariant(const struct lu_object *o);
824
825
826
827
828
829
830#define lu_object_exists(o) ((o)->lo_header->loh_attr & LOHA_EXISTS)
831
832
833
834
835#define lu_object_remote(o) unlikely((o)->lo_header->loh_attr & LOHA_REMOTE)
836
837static inline int lu_object_assert_exists(const struct lu_object *o)
838{
839 return lu_object_exists(o);
840}
841
842static inline int lu_object_assert_not_exists(const struct lu_object *o)
843{
844 return !lu_object_exists(o);
845}
846
847
848
849
850static inline __u32 lu_object_attr(const struct lu_object *o)
851{
852 LASSERT(lu_object_exists(o) != 0);
853 return o->lo_header->loh_attr;
854}
855
856static inline void lu_object_ref_add(struct lu_object *o,
857 const char *scope,
858 const void *source)
859{
860 lu_ref_add(&o->lo_header->loh_reference, scope, source);
861}
862
863static inline void lu_object_ref_add_at(struct lu_object *o,
864 struct lu_ref_link *link,
865 const char *scope,
866 const void *source)
867{
868 lu_ref_add_at(&o->lo_header->loh_reference, link, scope, source);
869}
870
871static inline void lu_object_ref_del(struct lu_object *o,
872 const char *scope, const void *source)
873{
874 lu_ref_del(&o->lo_header->loh_reference, scope, source);
875}
876
877static inline void lu_object_ref_del_at(struct lu_object *o,
878 struct lu_ref_link *link,
879 const char *scope, const void *source)
880{
881 lu_ref_del_at(&o->lo_header->loh_reference, link, scope, source);
882}
883
884
885struct lu_rdpg {
886
887 __u64 rp_hash;
888
889 unsigned int rp_count;
890
891 unsigned int rp_npages;
892
893 __u32 rp_attrs;
894
895 struct page **rp_pages;
896};
897
898enum lu_xattr_flags {
899 LU_XATTR_REPLACE = (1 << 0),
900 LU_XATTR_CREATE = (1 << 1)
901};
902
903
904
905
906
907
908
909
910enum lu_context_state {
911 LCS_INITIALIZED = 1,
912 LCS_ENTERED,
913 LCS_LEFT,
914 LCS_FINALIZED
915};
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938struct lu_context {
939
940
941
942
943
944
945
946
947
948
949 __u32 lc_tags;
950 enum lu_context_state lc_state;
951
952
953
954
955 struct ptlrpc_thread *lc_thread;
956
957
958
959
960 void **lc_value;
961
962
963
964
965
966 struct list_head lc_remember;
967
968
969
970
971 unsigned int lc_version;
972
973
974
975 unsigned int lc_cookie;
976};
977
978
979
980
981
982enum lu_context_tag {
983
984
985
986 LCT_MD_THREAD = 1 << 0,
987
988
989
990 LCT_DT_THREAD = 1 << 1,
991
992
993
994 LCT_TX_HANDLE = 1 << 2,
995
996
997
998 LCT_CL_THREAD = 1 << 3,
999
1000
1001
1002
1003 LCT_SESSION = 1 << 4,
1004
1005
1006
1007 LCT_OSP_THREAD = 1 << 5,
1008
1009
1010
1011 LCT_MG_THREAD = 1 << 6,
1012
1013
1014
1015 LCT_LOCAL = 1 << 7,
1016
1017
1018
1019 LCT_SERVER_SESSION = BIT(8),
1020
1021
1022
1023
1024
1025 LCT_HAS_EXIT = 1 << 28,
1026
1027
1028
1029
1030 LCT_NOREF = 1 << 29,
1031
1032
1033
1034 LCT_QUIESCENT = 1 << 30,
1035
1036
1037
1038 LCT_REMEMBER = 1 << 31,
1039
1040
1041
1042 LCT_SHRINKER = LCT_MD_THREAD | LCT_DT_THREAD | LCT_CL_THREAD |
1043 LCT_NOREF
1044};
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082struct lu_context_key {
1083
1084
1085
1086 __u32 lct_tags;
1087
1088
1089
1090
1091 void *(*lct_init)(const struct lu_context *ctx,
1092 struct lu_context_key *key);
1093
1094
1095
1096
1097
1098 void (*lct_fini)(const struct lu_context *ctx,
1099 struct lu_context_key *key, void *data);
1100
1101
1102
1103
1104
1105 void (*lct_exit)(const struct lu_context *ctx,
1106 struct lu_context_key *key, void *data);
1107
1108
1109
1110
1111 int lct_index;
1112
1113
1114
1115
1116 atomic_t lct_used;
1117
1118
1119
1120 struct module *lct_owner;
1121
1122
1123
1124 struct lu_ref lct_reference;
1125};
1126
1127#define LU_KEY_INIT(mod, type) \
1128 static void *mod##_key_init(const struct lu_context *ctx, \
1129 struct lu_context_key *key) \
1130 { \
1131 type *value; \
1132 \
1133 BUILD_BUG_ON(PAGE_SIZE < sizeof(*value)); \
1134 \
1135 value = kzalloc(sizeof(*value), GFP_NOFS); \
1136 if (!value) \
1137 value = ERR_PTR(-ENOMEM); \
1138 \
1139 return value; \
1140 } \
1141 struct __##mod##__dummy_init {; }
1142
1143#define LU_KEY_FINI(mod, type) \
1144 static void mod##_key_fini(const struct lu_context *ctx, \
1145 struct lu_context_key *key, void *data) \
1146 { \
1147 type *info = data; \
1148 \
1149 kfree(info); \
1150 } \
1151 struct __##mod##__dummy_fini {; }
1152
1153#define LU_KEY_INIT_FINI(mod, type) \
1154 LU_KEY_INIT(mod, type); \
1155 LU_KEY_FINI(mod, type)
1156
1157#define LU_CONTEXT_KEY_DEFINE(mod, tags) \
1158 struct lu_context_key mod##_thread_key = { \
1159 .lct_tags = tags, \
1160 .lct_init = mod##_key_init, \
1161 .lct_fini = mod##_key_fini \
1162 }
1163
1164#define LU_CONTEXT_KEY_INIT(key) \
1165do { \
1166 (key)->lct_owner = THIS_MODULE; \
1167} while (0)
1168
1169int lu_context_key_register(struct lu_context_key *key);
1170void lu_context_key_degister(struct lu_context_key *key);
1171void *lu_context_key_get(const struct lu_context *ctx,
1172 const struct lu_context_key *key);
1173void lu_context_key_quiesce(struct lu_context_key *key);
1174void lu_context_key_revive(struct lu_context_key *key);
1175
1176
1177
1178
1179
1180
1181#define LU_KEY_INIT_GENERIC(mod) \
1182 static void mod##_key_init_generic(struct lu_context_key *k, ...) \
1183 { \
1184 struct lu_context_key *key = k; \
1185 va_list args; \
1186 \
1187 va_start(args, k); \
1188 do { \
1189 LU_CONTEXT_KEY_INIT(key); \
1190 key = va_arg(args, struct lu_context_key *); \
1191 } while (key); \
1192 va_end(args); \
1193 }
1194
1195#define LU_TYPE_INIT(mod, ...) \
1196 LU_KEY_INIT_GENERIC(mod) \
1197 static int mod##_type_init(struct lu_device_type *t) \
1198 { \
1199 mod##_key_init_generic(__VA_ARGS__, NULL); \
1200 return lu_context_key_register_many(__VA_ARGS__, NULL); \
1201 } \
1202 struct __##mod##_dummy_type_init {; }
1203
1204#define LU_TYPE_FINI(mod, ...) \
1205 static void mod##_type_fini(struct lu_device_type *t) \
1206 { \
1207 lu_context_key_degister_many(__VA_ARGS__, NULL); \
1208 } \
1209 struct __##mod##_dummy_type_fini {; }
1210
1211#define LU_TYPE_START(mod, ...) \
1212 static void mod##_type_start(struct lu_device_type *t) \
1213 { \
1214 lu_context_key_revive_many(__VA_ARGS__, NULL); \
1215 } \
1216 struct __##mod##_dummy_type_start {; }
1217
1218#define LU_TYPE_STOP(mod, ...) \
1219 static void mod##_type_stop(struct lu_device_type *t) \
1220 { \
1221 lu_context_key_quiesce_many(__VA_ARGS__, NULL); \
1222 } \
1223 struct __##mod##_dummy_type_stop {; }
1224
1225#define LU_TYPE_INIT_FINI(mod, ...) \
1226 LU_TYPE_INIT(mod, __VA_ARGS__); \
1227 LU_TYPE_FINI(mod, __VA_ARGS__); \
1228 LU_TYPE_START(mod, __VA_ARGS__); \
1229 LU_TYPE_STOP(mod, __VA_ARGS__)
1230
1231int lu_context_init(struct lu_context *ctx, __u32 tags);
1232void lu_context_fini(struct lu_context *ctx);
1233void lu_context_enter(struct lu_context *ctx);
1234void lu_context_exit(struct lu_context *ctx);
1235int lu_context_refill(struct lu_context *ctx);
1236
1237
1238
1239
1240
1241
1242int lu_context_key_register_many(struct lu_context_key *k, ...);
1243void lu_context_key_degister_many(struct lu_context_key *k, ...);
1244void lu_context_key_revive_many(struct lu_context_key *k, ...);
1245void lu_context_key_quiesce_many(struct lu_context_key *k, ...);
1246
1247
1248
1249
1250struct lu_env {
1251
1252
1253
1254 struct lu_context le_ctx;
1255
1256
1257
1258 struct lu_context *le_ses;
1259};
1260
1261int lu_env_init(struct lu_env *env, __u32 tags);
1262void lu_env_fini(struct lu_env *env);
1263int lu_env_refill(struct lu_env *env);
1264
1265
1266
1267
1268
1269
1270
1271int lu_site_stats_print(const struct lu_site *s, struct seq_file *m);
1272
1273
1274
1275
1276struct lu_name {
1277 const char *ln_name;
1278 int ln_namelen;
1279};
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290static inline bool lu_name_is_valid_2(const char *name, size_t name_len)
1291{
1292 return name && name_len > 0 && name_len < INT_MAX &&
1293 name[name_len] == '\0' && strlen(name) == name_len &&
1294 !memchr(name, '/', name_len);
1295}
1296
1297
1298
1299
1300
1301struct lu_buf {
1302 void *lb_buf;
1303 size_t lb_len;
1304};
1305
1306#define DLUBUF "(%p %zu)"
1307#define PLUBUF(buf) (buf)->lb_buf, (buf)->lb_len
1308
1309
1310
1311
1312
1313
1314
1315
1316int lu_global_init(void);
1317
1318
1319
1320
1321void lu_global_fini(void);
1322
1323struct lu_kmem_descr {
1324 struct kmem_cache **ckd_cache;
1325 const char *ckd_name;
1326 const size_t ckd_size;
1327};
1328
1329int lu_kmem_init(struct lu_kmem_descr *caches);
1330void lu_kmem_fini(struct lu_kmem_descr *caches);
1331
1332void lu_buf_free(struct lu_buf *buf);
1333void lu_buf_alloc(struct lu_buf *buf, size_t size);
1334void lu_buf_realloc(struct lu_buf *buf, size_t size);
1335
1336int lu_buf_check_and_grow(struct lu_buf *buf, size_t len);
1337struct lu_buf *lu_buf_check_and_alloc(struct lu_buf *buf, size_t len);
1338
1339extern __u32 lu_context_tags_default;
1340extern __u32 lu_session_tags_default;
1341
1342
1343#endif
1344