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