1
2
3
4
5
6
7
8
9
10#ifndef __INCORE_DOT_H__
11#define __INCORE_DOT_H__
12
13#include <linux/fs.h>
14#include <linux/kobject.h>
15#include <linux/workqueue.h>
16#include <linux/dlm.h>
17#include <linux/buffer_head.h>
18#include <linux/rcupdate.h>
19#include <linux/rculist_bl.h>
20#include <linux/completion.h>
21#include <linux/rbtree.h>
22#include <linux/ktime.h>
23#include <linux/percpu.h>
24#include <linux/lockref.h>
25#include <linux/rhashtable.h>
26
27#define DIO_WAIT 0x00000010
28#define DIO_METADATA 0x00000020
29
30struct gfs2_log_operations;
31struct gfs2_bufdata;
32struct gfs2_holder;
33struct gfs2_glock;
34struct gfs2_quota_data;
35struct gfs2_trans;
36struct gfs2_jdesc;
37struct gfs2_sbd;
38struct lm_lockops;
39
40typedef void (*gfs2_glop_bh_t) (struct gfs2_glock *gl, unsigned int ret);
41
42struct gfs2_log_header_host {
43 u64 lh_sequence;
44 u32 lh_flags;
45 u32 lh_tail;
46 u32 lh_blkno;
47};
48
49
50
51
52
53
54struct gfs2_log_operations {
55 void (*lo_before_commit) (struct gfs2_sbd *sdp, struct gfs2_trans *tr);
56 void (*lo_after_commit) (struct gfs2_sbd *sdp, struct gfs2_trans *tr);
57 void (*lo_before_scan) (struct gfs2_jdesc *jd,
58 struct gfs2_log_header_host *head, int pass);
59 int (*lo_scan_elements) (struct gfs2_jdesc *jd, unsigned int start,
60 struct gfs2_log_descriptor *ld, __be64 *ptr,
61 int pass);
62 void (*lo_after_scan) (struct gfs2_jdesc *jd, int error, int pass);
63 const char *lo_name;
64};
65
66#define GBF_FULL 1
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89struct gfs2_bitmap {
90 struct buffer_head *bi_bh;
91 char *bi_clone;
92 unsigned long bi_flags;
93 u32 bi_offset;
94 u32 bi_start;
95 u32 bi_len;
96 u32 bi_blocks;
97};
98
99struct gfs2_rgrpd {
100 struct rb_node rd_node;
101 struct gfs2_glock *rd_gl;
102 u64 rd_addr;
103 u64 rd_data0;
104 u32 rd_length;
105 u32 rd_data;
106 u32 rd_bitbytes;
107 u32 rd_free;
108 u32 rd_reserved;
109 u32 rd_free_clone;
110 u32 rd_dinodes;
111 u64 rd_igeneration;
112 struct gfs2_bitmap *rd_bits;
113 struct gfs2_sbd *rd_sbd;
114 struct gfs2_rgrp_lvb *rd_rgl;
115 u32 rd_last_alloc;
116 u32 rd_flags;
117 u32 rd_extfail_pt;
118#define GFS2_RDF_CHECK 0x10000000
119#define GFS2_RDF_UPTODATE 0x20000000
120#define GFS2_RDF_ERROR 0x40000000
121#define GFS2_RDF_PREFERRED 0x80000000
122#define GFS2_RDF_MASK 0xf0000000
123 spinlock_t rd_rsspin;
124 struct rb_root rd_rstree;
125};
126
127struct gfs2_rbm {
128 struct gfs2_rgrpd *rgd;
129 u32 offset;
130 int bii;
131};
132
133static inline struct gfs2_bitmap *rbm_bi(const struct gfs2_rbm *rbm)
134{
135 return rbm->rgd->rd_bits + rbm->bii;
136}
137
138static inline u64 gfs2_rbm_to_block(const struct gfs2_rbm *rbm)
139{
140 BUG_ON(rbm->offset >= rbm->rgd->rd_data);
141 return rbm->rgd->rd_data0 + (rbm_bi(rbm)->bi_start * GFS2_NBBY) +
142 rbm->offset;
143}
144
145static inline bool gfs2_rbm_eq(const struct gfs2_rbm *rbm1,
146 const struct gfs2_rbm *rbm2)
147{
148 return (rbm1->rgd == rbm2->rgd) && (rbm1->bii == rbm2->bii) &&
149 (rbm1->offset == rbm2->offset);
150}
151
152enum gfs2_state_bits {
153 BH_Pinned = BH_PrivateStart,
154 BH_Escaped = BH_PrivateStart + 1,
155};
156
157BUFFER_FNS(Pinned, pinned)
158TAS_BUFFER_FNS(Pinned, pinned)
159BUFFER_FNS(Escaped, escaped)
160TAS_BUFFER_FNS(Escaped, escaped)
161
162struct gfs2_bufdata {
163 struct buffer_head *bd_bh;
164 struct gfs2_glock *bd_gl;
165 u64 bd_blkno;
166
167 struct list_head bd_list;
168 const struct gfs2_log_operations *bd_ops;
169
170 struct gfs2_trans *bd_tr;
171 struct list_head bd_ail_st_list;
172 struct list_head bd_ail_gl_list;
173};
174
175
176
177
178
179
180#define GDLM_STRNAME_BYTES 25
181#define GDLM_LVB_SIZE 32
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214enum {
215 DFL_BLOCK_LOCKS = 0,
216 DFL_NO_DLM_OPS = 1,
217 DFL_FIRST_MOUNT = 2,
218 DFL_FIRST_MOUNT_DONE = 3,
219 DFL_MOUNT_DONE = 4,
220 DFL_UNMOUNT = 5,
221 DFL_DLM_RECOVERY = 6,
222};
223
224
225
226
227
228struct lm_lockname {
229 u64 ln_number;
230 struct gfs2_sbd *ln_sbd;
231 unsigned int ln_type;
232};
233
234#define lm_name_equal(name1, name2) \
235 (((name1)->ln_number == (name2)->ln_number) && \
236 ((name1)->ln_type == (name2)->ln_type) && \
237 ((name1)->ln_sbd == (name2)->ln_sbd))
238
239
240struct gfs2_glock_operations {
241 void (*go_sync) (struct gfs2_glock *gl);
242 int (*go_xmote_bh) (struct gfs2_glock *gl, struct gfs2_holder *gh);
243 void (*go_inval) (struct gfs2_glock *gl, int flags);
244 int (*go_demote_ok) (const struct gfs2_glock *gl);
245 int (*go_lock) (struct gfs2_holder *gh);
246 void (*go_unlock) (struct gfs2_holder *gh);
247 void (*go_dump)(struct seq_file *seq, const struct gfs2_glock *gl);
248 void (*go_callback)(struct gfs2_glock *gl, bool remote);
249 const int go_type;
250 const unsigned long go_flags;
251#define GLOF_ASPACE 1
252#define GLOF_LVB 2
253#define GLOF_LRU 4
254};
255
256enum {
257 GFS2_LKS_SRTT = 0,
258 GFS2_LKS_SRTTVAR = 1,
259 GFS2_LKS_SRTTB = 2,
260 GFS2_LKS_SRTTVARB = 3,
261 GFS2_LKS_SIRT = 4,
262 GFS2_LKS_SIRTVAR = 5,
263 GFS2_LKS_DCOUNT = 6,
264 GFS2_LKS_QCOUNT = 7,
265 GFS2_NR_LKSTATS
266};
267
268struct gfs2_lkstats {
269 u64 stats[GFS2_NR_LKSTATS];
270};
271
272enum {
273
274 HIF_HOLDER = 6,
275 HIF_FIRST = 7,
276 HIF_WAIT = 10,
277};
278
279struct gfs2_holder {
280 struct list_head gh_list;
281
282 struct gfs2_glock *gh_gl;
283 struct pid *gh_owner_pid;
284 u16 gh_flags;
285 u16 gh_state;
286
287 int gh_error;
288 unsigned long gh_iflags;
289 unsigned long gh_ip;
290};
291
292
293#define GFS2_MAXQUOTAS 2
294
295struct gfs2_qadata {
296
297 struct gfs2_quota_data *qa_qd[2 * GFS2_MAXQUOTAS];
298 struct gfs2_holder qa_qd_ghs[2 * GFS2_MAXQUOTAS];
299 unsigned int qa_qd_num;
300};
301
302
303
304
305
306
307
308
309
310
311struct gfs2_blkreserv {
312
313 atomic_t rs_sizehint;
314
315 struct gfs2_holder rs_rgd_gh;
316 struct rb_node rs_node;
317 struct gfs2_rbm rs_rbm;
318 u32 rs_free;
319};
320
321
322
323
324
325
326
327
328
329
330struct gfs2_alloc_parms {
331 u64 target;
332 u32 min_target;
333 u32 aflags;
334 u64 allowed;
335};
336
337enum {
338 GLF_LOCK = 1,
339 GLF_DEMOTE = 3,
340 GLF_PENDING_DEMOTE = 4,
341 GLF_DEMOTE_IN_PROGRESS = 5,
342 GLF_DIRTY = 6,
343 GLF_LFLUSH = 7,
344 GLF_INVALIDATE_IN_PROGRESS = 8,
345 GLF_REPLY_PENDING = 9,
346 GLF_INITIAL = 10,
347 GLF_FROZEN = 11,
348 GLF_QUEUED = 12,
349 GLF_LRU = 13,
350 GLF_OBJECT = 14,
351 GLF_BLOCKING = 15,
352 GLF_INODE_CREATING = 16,
353};
354
355struct gfs2_glock {
356 unsigned long gl_flags;
357 struct lm_lockname gl_name;
358
359 struct lockref gl_lockref;
360
361
362 unsigned int gl_state:2,
363 gl_target:2,
364 gl_demote_state:2,
365 gl_req:2,
366 gl_reply:8;
367
368 unsigned long gl_demote_time;
369 long gl_hold_time;
370 struct list_head gl_holders;
371
372 const struct gfs2_glock_operations *gl_ops;
373 ktime_t gl_dstamp;
374 struct gfs2_lkstats gl_stats;
375 struct dlm_lksb gl_lksb;
376 unsigned long gl_tchange;
377 void *gl_object;
378
379 struct list_head gl_lru;
380 struct list_head gl_ail_list;
381 atomic_t gl_ail_count;
382 atomic_t gl_revokes;
383 struct delayed_work gl_work;
384 union {
385
386 struct work_struct gl_delete;
387
388 struct {
389 loff_t start;
390 loff_t end;
391 } gl_vm;
392 };
393 struct rcu_head gl_rcu;
394 struct rhash_head gl_node;
395};
396
397#define GFS2_MIN_LVB_SIZE 32
398
399enum {
400 GIF_INVALID = 0,
401 GIF_QD_LOCKED = 1,
402 GIF_ALLOC_FAILED = 2,
403 GIF_SW_PAGED = 3,
404 GIF_ORDERED = 4,
405 GIF_FREE_VFS_INODE = 5,
406 GIF_GLOP_PENDING = 6,
407};
408
409struct gfs2_inode {
410 struct inode i_inode;
411 u64 i_no_addr;
412 u64 i_no_formal_ino;
413 u64 i_generation;
414 u64 i_eattr;
415 unsigned long i_flags;
416 struct gfs2_glock *i_gl;
417 struct gfs2_holder i_iopen_gh;
418 struct gfs2_holder i_gh;
419 struct gfs2_qadata *i_qadata;
420 struct gfs2_blkreserv i_res;
421 u64 i_goal;
422 struct rw_semaphore i_rw_mutex;
423 struct list_head i_ordered;
424 struct list_head i_trunc_list;
425 __be64 *i_hash_cache;
426 u32 i_entries;
427 u32 i_diskflags;
428 u8 i_height;
429 u8 i_depth;
430 u16 i_rahead;
431};
432
433
434
435
436
437static inline struct gfs2_inode *GFS2_I(struct inode *inode)
438{
439 return container_of(inode, struct gfs2_inode, i_inode);
440}
441
442static inline struct gfs2_sbd *GFS2_SB(const struct inode *inode)
443{
444 return inode->i_sb->s_fs_info;
445}
446
447struct gfs2_file {
448 struct mutex f_fl_mutex;
449 struct gfs2_holder f_fl_gh;
450};
451
452struct gfs2_revoke_replay {
453 struct list_head rr_list;
454 u64 rr_blkno;
455 unsigned int rr_where;
456};
457
458enum {
459 QDF_CHANGE = 1,
460 QDF_LOCKED = 2,
461 QDF_REFRESH = 3,
462 QDF_QMSG_QUIET = 4,
463};
464
465struct gfs2_quota_data {
466 struct hlist_bl_node qd_hlist;
467 struct list_head qd_list;
468 struct kqid qd_id;
469 struct gfs2_sbd *qd_sbd;
470 struct lockref qd_lockref;
471 struct list_head qd_lru;
472 unsigned qd_hash;
473
474 unsigned long qd_flags;
475
476 s64 qd_change;
477 s64 qd_change_sync;
478
479 unsigned int qd_slot;
480 unsigned int qd_slot_count;
481
482 struct buffer_head *qd_bh;
483 struct gfs2_quota_change *qd_bh_qc;
484 unsigned int qd_bh_count;
485
486 struct gfs2_glock *qd_gl;
487 struct gfs2_quota_lvb qd_qb;
488
489 u64 qd_sync_gen;
490 unsigned long qd_last_warn;
491 struct rcu_head qd_rcu;
492};
493
494enum {
495 TR_TOUCHED = 1,
496 TR_ATTACHED = 2,
497 TR_ALLOCED = 3,
498};
499
500struct gfs2_trans {
501 unsigned long tr_ip;
502
503 unsigned int tr_blocks;
504 unsigned int tr_revokes;
505 unsigned int tr_reserved;
506 unsigned long tr_flags;
507
508 unsigned int tr_num_buf_new;
509 unsigned int tr_num_databuf_new;
510 unsigned int tr_num_buf_rm;
511 unsigned int tr_num_databuf_rm;
512 unsigned int tr_num_revoke;
513 unsigned int tr_num_revoke_rm;
514
515 struct list_head tr_list;
516 struct list_head tr_databuf;
517 struct list_head tr_buf;
518
519 unsigned int tr_first;
520 struct list_head tr_ail1_list;
521 struct list_head tr_ail2_list;
522};
523
524struct gfs2_journal_extent {
525 struct list_head list;
526
527 unsigned int lblock;
528 u64 dblock;
529 u64 blocks;
530};
531
532struct gfs2_jdesc {
533 struct list_head jd_list;
534 struct list_head extent_list;
535 unsigned int nr_extents;
536 struct work_struct jd_work;
537 struct inode *jd_inode;
538 unsigned long jd_flags;
539#define JDF_RECOVERY 1
540 unsigned int jd_jid;
541 unsigned int jd_blocks;
542 int jd_recover_error;
543
544
545 unsigned int jd_found_blocks;
546 unsigned int jd_found_revokes;
547 unsigned int jd_replayed_blocks;
548
549 struct list_head jd_revoke_list;
550 unsigned int jd_replay_tail;
551
552};
553
554struct gfs2_statfs_change_host {
555 s64 sc_total;
556 s64 sc_free;
557 s64 sc_dinodes;
558};
559
560#define GFS2_QUOTA_DEFAULT GFS2_QUOTA_OFF
561#define GFS2_QUOTA_OFF 0
562#define GFS2_QUOTA_ACCOUNT 1
563#define GFS2_QUOTA_ON 2
564
565#define GFS2_DATA_DEFAULT GFS2_DATA_ORDERED
566#define GFS2_DATA_WRITEBACK 1
567#define GFS2_DATA_ORDERED 2
568
569#define GFS2_ERRORS_DEFAULT GFS2_ERRORS_WITHDRAW
570#define GFS2_ERRORS_WITHDRAW 0
571#define GFS2_ERRORS_CONTINUE 1
572#define GFS2_ERRORS_RO 2
573#define GFS2_ERRORS_PANIC 3
574
575struct gfs2_args {
576 char ar_lockproto[GFS2_LOCKNAME_LEN];
577 char ar_locktable[GFS2_LOCKNAME_LEN];
578 char ar_hostdata[GFS2_LOCKNAME_LEN];
579 unsigned int ar_spectator:1;
580 unsigned int ar_localflocks:1;
581 unsigned int ar_debug:1;
582 unsigned int ar_posix_acl:1;
583 unsigned int ar_quota:2;
584 unsigned int ar_suiddir:1;
585 unsigned int ar_data:2;
586 unsigned int ar_meta:1;
587 unsigned int ar_discard:1;
588 unsigned int ar_errors:2;
589 unsigned int ar_nobarrier:1;
590 unsigned int ar_rgrplvb:1;
591 unsigned int ar_loccookie:1;
592
593 int ar_commit;
594 int ar_statfs_quantum;
595 int ar_quota_quantum;
596 int ar_statfs_percent;
597};
598
599struct gfs2_tune {
600 spinlock_t gt_spin;
601
602 unsigned int gt_logd_secs;
603
604 unsigned int gt_quota_warn_period;
605 unsigned int gt_quota_scale_num;
606 unsigned int gt_quota_scale_den;
607 unsigned int gt_quota_quantum;
608 unsigned int gt_new_files_jdata;
609 unsigned int gt_max_readahead;
610 unsigned int gt_complain_secs;
611 unsigned int gt_statfs_quantum;
612 unsigned int gt_statfs_slow;
613};
614
615enum {
616 SDF_JOURNAL_CHECKED = 0,
617 SDF_JOURNAL_LIVE = 1,
618 SDF_SHUTDOWN = 2,
619 SDF_NOBARRIERS = 3,
620 SDF_NORECOVERY = 4,
621 SDF_DEMOTE = 5,
622 SDF_NOJOURNALID = 6,
623 SDF_RORECOVERY = 7,
624 SDF_SKIP_DLM_UNLOCK = 8,
625 SDF_FORCE_AIL_FLUSH = 9,
626};
627
628enum gfs2_freeze_state {
629 SFS_UNFROZEN = 0,
630 SFS_STARTING_FREEZE = 1,
631 SFS_FROZEN = 2,
632};
633
634#define GFS2_FSNAME_LEN 256
635
636struct gfs2_inum_host {
637 u64 no_formal_ino;
638 u64 no_addr;
639};
640
641struct gfs2_sb_host {
642 u32 sb_magic;
643 u32 sb_type;
644 u32 sb_format;
645
646 u32 sb_fs_format;
647 u32 sb_multihost_format;
648 u32 sb_bsize;
649 u32 sb_bsize_shift;
650
651 struct gfs2_inum_host sb_master_dir;
652 struct gfs2_inum_host sb_root_dir;
653
654 char sb_lockproto[GFS2_LOCKNAME_LEN];
655 char sb_locktable[GFS2_LOCKNAME_LEN];
656};
657
658
659
660
661
662
663
664
665
666
667struct lm_lockstruct {
668 int ls_jid;
669 unsigned int ls_first;
670 const struct lm_lockops *ls_ops;
671 dlm_lockspace_t *ls_dlm;
672
673 int ls_recover_jid_done;
674 int ls_recover_jid_status;
675
676 struct dlm_lksb ls_mounted_lksb;
677 struct dlm_lksb ls_control_lksb;
678 char ls_control_lvb[GDLM_LVB_SIZE];
679 struct completion ls_sync_wait;
680 char *ls_lvb_bits;
681
682 spinlock_t ls_recover_spin;
683 unsigned long ls_recover_flags;
684 uint32_t ls_recover_mount;
685 uint32_t ls_recover_start;
686 uint32_t ls_recover_block;
687 uint32_t ls_recover_size;
688 uint32_t *ls_recover_submit;
689 uint32_t *ls_recover_result;
690};
691
692struct gfs2_pcpu_lkstats {
693
694 struct gfs2_lkstats lkstats[10];
695};
696
697struct gfs2_sbd {
698 struct super_block *sd_vfs;
699 struct gfs2_pcpu_lkstats __percpu *sd_lkstats;
700 struct kobject sd_kobj;
701 unsigned long sd_flags;
702 struct gfs2_sb_host sd_sb;
703
704
705
706 u32 sd_fsb2bb;
707 u32 sd_fsb2bb_shift;
708 u32 sd_diptrs;
709 u32 sd_inptrs;
710 u32 sd_jbsize;
711 u32 sd_hash_bsize;
712 u32 sd_hash_bsize_shift;
713 u32 sd_hash_ptrs;
714 u32 sd_qc_per_block;
715 u32 sd_blocks_per_bitmap;
716 u32 sd_max_dirres;
717 u32 sd_max_height;
718 u64 sd_heightsize[GFS2_MAX_META_HEIGHT + 1];
719 u32 sd_max_dents_per_leaf;
720
721 struct gfs2_args sd_args;
722 struct gfs2_tune sd_tune;
723
724
725
726 struct lm_lockstruct sd_lockstruct;
727 struct gfs2_holder sd_live_gh;
728 struct gfs2_glock *sd_rename_gl;
729 struct gfs2_glock *sd_freeze_gl;
730 struct work_struct sd_freeze_work;
731 wait_queue_head_t sd_glock_wait;
732 atomic_t sd_glock_disposal;
733 struct completion sd_locking_init;
734 struct completion sd_wdack;
735 struct delayed_work sd_control_work;
736
737
738
739 struct dentry *sd_master_dir;
740 struct dentry *sd_root_dir;
741
742 struct inode *sd_jindex;
743 struct inode *sd_statfs_inode;
744 struct inode *sd_sc_inode;
745 struct inode *sd_qc_inode;
746 struct inode *sd_rindex;
747 struct inode *sd_quota_inode;
748
749
750
751 spinlock_t sd_statfs_spin;
752 struct gfs2_statfs_change_host sd_statfs_master;
753 struct gfs2_statfs_change_host sd_statfs_local;
754 int sd_statfs_force_sync;
755
756
757
758 int sd_rindex_uptodate;
759 spinlock_t sd_rindex_spin;
760 struct rb_root sd_rindex_tree;
761 unsigned int sd_rgrps;
762 unsigned int sd_max_rg_data;
763
764
765
766 struct list_head sd_jindex_list;
767 spinlock_t sd_jindex_spin;
768 struct mutex sd_jindex_mutex;
769 unsigned int sd_journals;
770
771 struct gfs2_jdesc *sd_jdesc;
772 struct gfs2_holder sd_journal_gh;
773 struct gfs2_holder sd_jinode_gh;
774
775 struct gfs2_holder sd_sc_gh;
776 struct gfs2_holder sd_qc_gh;
777
778 struct completion sd_journal_ready;
779
780
781
782 struct task_struct *sd_logd_process;
783 struct task_struct *sd_quotad_process;
784
785
786
787 struct list_head sd_quota_list;
788 atomic_t sd_quota_count;
789 struct mutex sd_quota_mutex;
790 struct mutex sd_quota_sync_mutex;
791 wait_queue_head_t sd_quota_wait;
792 struct list_head sd_trunc_list;
793 spinlock_t sd_trunc_lock;
794
795 unsigned int sd_quota_slots;
796 unsigned long *sd_quota_bitmap;
797 spinlock_t sd_bitmap_lock;
798
799 u64 sd_quota_sync_gen;
800
801
802
803 struct address_space sd_aspace;
804
805 spinlock_t sd_log_lock;
806
807 struct gfs2_trans *sd_log_tr;
808 unsigned int sd_log_blks_reserved;
809 int sd_log_commited_revoke;
810
811 atomic_t sd_log_pinned;
812 unsigned int sd_log_num_revoke;
813
814 struct list_head sd_log_le_revoke;
815 struct list_head sd_log_le_ordered;
816 spinlock_t sd_ordered_lock;
817
818 atomic_t sd_log_thresh1;
819 atomic_t sd_log_thresh2;
820 atomic_t sd_log_blks_free;
821 atomic_t sd_log_blks_needed;
822 wait_queue_head_t sd_log_waitq;
823 wait_queue_head_t sd_logd_waitq;
824
825 u64 sd_log_sequence;
826 unsigned int sd_log_head;
827 unsigned int sd_log_tail;
828 int sd_log_idle;
829
830 struct rw_semaphore sd_log_flush_lock;
831 atomic_t sd_log_in_flight;
832 struct bio *sd_log_bio;
833 wait_queue_head_t sd_log_flush_wait;
834 int sd_log_error;
835
836 atomic_t sd_reserving_log;
837 wait_queue_head_t sd_reserving_log_wait;
838
839 unsigned int sd_log_flush_head;
840
841 spinlock_t sd_ail_lock;
842 struct list_head sd_ail1_list;
843 struct list_head sd_ail2_list;
844
845
846 struct gfs2_holder sd_freeze_gh;
847 atomic_t sd_freeze_state;
848 struct mutex sd_freeze_mutex;
849
850 char sd_fsname[GFS2_FSNAME_LEN + 3 * sizeof(int) + 2];
851 char sd_table_name[GFS2_FSNAME_LEN];
852 char sd_proto_name[GFS2_FSNAME_LEN];
853
854
855
856 unsigned long sd_last_warning;
857 struct dentry *debugfs_dir;
858 struct dentry *debugfs_dentry_glocks;
859 struct dentry *debugfs_dentry_glstats;
860 struct dentry *debugfs_dentry_sbstats;
861};
862
863static inline void gfs2_glstats_inc(struct gfs2_glock *gl, int which)
864{
865 gl->gl_stats.stats[which]++;
866}
867
868static inline void gfs2_sbstats_inc(const struct gfs2_glock *gl, int which)
869{
870 const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
871 preempt_disable();
872 this_cpu_ptr(sdp->sd_lkstats)->lkstats[gl->gl_name.ln_type].stats[which]++;
873 preempt_enable();
874}
875
876extern struct gfs2_rgrpd *gfs2_glock2rgrp(struct gfs2_glock *gl);
877
878static inline unsigned gfs2_max_stuffed_size(const struct gfs2_inode *ip)
879{
880 return GFS2_SB(&ip->i_inode)->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
881}
882
883#endif
884
885