aboutsummaryrefslogtreecommitdiffstats
path: root/include/linux
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2015-09-03 15:28:30 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2015-09-03 15:28:30 -0400
commite31fb9e00543e5d3c5b686747d3c862bc09b59f3 (patch)
tree4300b111471a858b542d55d47d587fb8ef52513a /include/linux
parent824b005c86f91fe02eb2743a4526361f11786f70 (diff)
parent9181f8bf5abf4b9d59b12e878895375b84fe32ba (diff)
Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs
Pull ext3 removal, quota & udf fixes from Jan Kara: "The biggest change in the pull is the removal of ext3 filesystem driver (~28k lines removed). Ext4 driver is a full featured replacement these days and both RH and SUSE use it for several years without issues. Also there are some workarounds in VM & block layer mainly for ext3 which we could eventually get rid of. Other larger change is addition of proper error handling for dquot_initialize(). The rest is small fixes and cleanups" [ I wasn't convinced about the ext3 removal and worried about things falling through the cracks for legacy users, but ext4 maintainers piped up and were all unanimously in favor of removal, and maintaining all legacy ext3 support inside ext4. - Linus ] * 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs: udf: Don't modify filesystem for read-only mounts quota: remove an unneeded condition ext4: memory leak on error in ext4_symlink() mm/Kconfig: NEED_BOUNCE_POOL: clean-up condition ext4: Improve ext4 Kconfig test block: Remove forced page bouncing under IO fs: Remove ext3 filesystem driver doc: Update doc about journalling layer jfs: Handle error from dquot_initialize() reiserfs: Handle error from dquot_initialize() ocfs2: Handle error from dquot_initialize() ext4: Handle error from dquot_initialize() ext2: Handle error from dquot_initalize() quota: Propagate error from ->acquire_dquot()
Diffstat (limited to 'include/linux')
-rw-r--r--include/linux/blk_types.h5
-rw-r--r--include/linux/jbd.h1047
-rw-r--r--include/linux/jbd2.h41
-rw-r--r--include/linux/jbd_common.h46
-rw-r--r--include/linux/quotaops.h5
5 files changed, 45 insertions, 1099 deletions
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 4b7b4ebaa633..e8130138f29d 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -118,9 +118,8 @@ struct bio {
118#define BIO_USER_MAPPED 4 /* contains user pages */ 118#define BIO_USER_MAPPED 4 /* contains user pages */
119#define BIO_NULL_MAPPED 5 /* contains invalid user pages */ 119#define BIO_NULL_MAPPED 5 /* contains invalid user pages */
120#define BIO_QUIET 6 /* Make BIO Quiet */ 120#define BIO_QUIET 6 /* Make BIO Quiet */
121#define BIO_SNAP_STABLE 7 /* bio data must be snapshotted during write */ 121#define BIO_CHAIN 7 /* chained bio, ->bi_remaining in effect */
122#define BIO_CHAIN 8 /* chained bio, ->bi_remaining in effect */ 122#define BIO_REFFED 8 /* bio has elevated ->bi_cnt */
123#define BIO_REFFED 9 /* bio has elevated ->bi_cnt */
124 123
125/* 124/*
126 * Flags starting here get preserved by bio_reset() - this includes 125 * Flags starting here get preserved by bio_reset() - this includes
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
deleted file mode 100644
index d32615280be9..000000000000
--- a/include/linux/jbd.h
+++ /dev/null
@@ -1,1047 +0,0 @@
1/*
2 * linux/include/linux/jbd.h
3 *
4 * Written by Stephen C. Tweedie <sct@redhat.com>
5 *
6 * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
7 *
8 * This file is part of the Linux kernel and is made available under
9 * the terms of the GNU General Public License, version 2, or at your
10 * option, any later version, incorporated herein by reference.
11 *
12 * Definitions for transaction data structures for the buffer cache
13 * filesystem journaling support.
14 */
15
16#ifndef _LINUX_JBD_H
17#define _LINUX_JBD_H
18
19/* Allow this file to be included directly into e2fsprogs */
20#ifndef __KERNEL__
21#include "jfs_compat.h"
22#define JFS_DEBUG
23#define jfs_debug jbd_debug
24#else
25
26#include <linux/types.h>
27#include <linux/buffer_head.h>
28#include <linux/journal-head.h>
29#include <linux/stddef.h>
30#include <linux/mutex.h>
31#include <linux/timer.h>
32#include <linux/lockdep.h>
33#include <linux/slab.h>
34
35#define journal_oom_retry 1
36
37/*
38 * Define JBD_PARANOID_IOFAIL to cause a kernel BUG() if ext3 finds
39 * certain classes of error which can occur due to failed IOs. Under
40 * normal use we want ext3 to continue after such errors, because
41 * hardware _can_ fail, but for debugging purposes when running tests on
42 * known-good hardware we may want to trap these errors.
43 */
44#undef JBD_PARANOID_IOFAIL
45
46/*
47 * The default maximum commit age, in seconds.
48 */
49#define JBD_DEFAULT_MAX_COMMIT_AGE 5
50
51#ifdef CONFIG_JBD_DEBUG
52/*
53 * Define JBD_EXPENSIVE_CHECKING to enable more expensive internal
54 * consistency checks. By default we don't do this unless
55 * CONFIG_JBD_DEBUG is on.
56 */
57#define JBD_EXPENSIVE_CHECKING
58extern u8 journal_enable_debug;
59
60void __jbd_debug(int level, const char *file, const char *func,
61 unsigned int line, const char *fmt, ...);
62
63#define jbd_debug(n, fmt, a...) \
64 __jbd_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
65#else
66#define jbd_debug(n, fmt, a...) /**/
67#endif
68
69static inline void *jbd_alloc(size_t size, gfp_t flags)
70{
71 return (void *)__get_free_pages(flags, get_order(size));
72}
73
74static inline void jbd_free(void *ptr, size_t size)
75{
76 free_pages((unsigned long)ptr, get_order(size));
77}
78
79#define JFS_MIN_JOURNAL_BLOCKS 1024
80
81
82/**
83 * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
84 *
85 * All filesystem modifications made by the process go
86 * through this handle. Recursive operations (such as quota operations)
87 * are gathered into a single update.
88 *
89 * The buffer credits field is used to account for journaled buffers
90 * being modified by the running process. To ensure that there is
91 * enough log space for all outstanding operations, we need to limit the
92 * number of outstanding buffers possible at any time. When the
93 * operation completes, any buffer credits not used are credited back to
94 * the transaction, so that at all times we know how many buffers the
95 * outstanding updates on a transaction might possibly touch.
96 *
97 * This is an opaque datatype.
98 **/
99typedef struct handle_s handle_t; /* Atomic operation type */
100
101
102/**
103 * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
104 *
105 * journal_t is linked to from the fs superblock structure.
106 *
107 * We use the journal_t to keep track of all outstanding transaction
108 * activity on the filesystem, and to manage the state of the log
109 * writing process.
110 *
111 * This is an opaque datatype.
112 **/
113typedef struct journal_s journal_t; /* Journal control structure */
114#endif
115
116/*
117 * Internal structures used by the logging mechanism:
118 */
119
120#define JFS_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
121
122/*
123 * On-disk structures
124 */
125
126/*
127 * Descriptor block types:
128 */
129
130#define JFS_DESCRIPTOR_BLOCK 1
131#define JFS_COMMIT_BLOCK 2
132#define JFS_SUPERBLOCK_V1 3
133#define JFS_SUPERBLOCK_V2 4
134#define JFS_REVOKE_BLOCK 5
135
136/*
137 * Standard header for all descriptor blocks:
138 */
139typedef struct journal_header_s
140{
141 __be32 h_magic;
142 __be32 h_blocktype;
143 __be32 h_sequence;
144} journal_header_t;
145
146
147/*
148 * The block tag: used to describe a single buffer in the journal
149 */
150typedef struct journal_block_tag_s
151{
152 __be32 t_blocknr; /* The on-disk block number */
153 __be32 t_flags; /* See below */
154} journal_block_tag_t;
155
156/*
157 * The revoke descriptor: used on disk to describe a series of blocks to
158 * be revoked from the log
159 */
160typedef struct journal_revoke_header_s
161{
162 journal_header_t r_header;
163 __be32 r_count; /* Count of bytes used in the block */
164} journal_revoke_header_t;
165
166
167/* Definitions for the journal tag flags word: */
168#define JFS_FLAG_ESCAPE 1 /* on-disk block is escaped */
169#define JFS_FLAG_SAME_UUID 2 /* block has same uuid as previous */
170#define JFS_FLAG_DELETED 4 /* block deleted by this transaction */
171#define JFS_FLAG_LAST_TAG 8 /* last tag in this descriptor block */
172
173
174/*
175 * The journal superblock. All fields are in big-endian byte order.
176 */
177typedef struct journal_superblock_s
178{
179/* 0x0000 */
180 journal_header_t s_header;
181
182/* 0x000C */
183 /* Static information describing the journal */
184 __be32 s_blocksize; /* journal device blocksize */
185 __be32 s_maxlen; /* total blocks in journal file */
186 __be32 s_first; /* first block of log information */
187
188/* 0x0018 */
189 /* Dynamic information describing the current state of the log */
190 __be32 s_sequence; /* first commit ID expected in log */
191 __be32 s_start; /* blocknr of start of log */
192
193/* 0x0020 */
194 /* Error value, as set by journal_abort(). */
195 __be32 s_errno;
196
197/* 0x0024 */
198 /* Remaining fields are only valid in a version-2 superblock */
199 __be32 s_feature_compat; /* compatible feature set */
200 __be32 s_feature_incompat; /* incompatible feature set */
201 __be32 s_feature_ro_compat; /* readonly-compatible feature set */
202/* 0x0030 */
203 __u8 s_uuid[16]; /* 128-bit uuid for journal */
204
205/* 0x0040 */
206 __be32 s_nr_users; /* Nr of filesystems sharing log */
207
208 __be32 s_dynsuper; /* Blocknr of dynamic superblock copy*/
209
210/* 0x0048 */
211 __be32 s_max_transaction; /* Limit of journal blocks per trans.*/
212 __be32 s_max_trans_data; /* Limit of data blocks per trans. */
213
214/* 0x0050 */
215 __u32 s_padding[44];
216
217/* 0x0100 */
218 __u8 s_users[16*48]; /* ids of all fs'es sharing the log */
219/* 0x0400 */
220} journal_superblock_t;
221
222#define JFS_HAS_COMPAT_FEATURE(j,mask) \
223 ((j)->j_format_version >= 2 && \
224 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
225#define JFS_HAS_RO_COMPAT_FEATURE(j,mask) \
226 ((j)->j_format_version >= 2 && \
227 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
228#define JFS_HAS_INCOMPAT_FEATURE(j,mask) \
229 ((j)->j_format_version >= 2 && \
230 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
231
232#define JFS_FEATURE_INCOMPAT_REVOKE 0x00000001
233
234/* Features known to this kernel version: */
235#define JFS_KNOWN_COMPAT_FEATURES 0
236#define JFS_KNOWN_ROCOMPAT_FEATURES 0
237#define JFS_KNOWN_INCOMPAT_FEATURES JFS_FEATURE_INCOMPAT_REVOKE
238
239#ifdef __KERNEL__
240
241#include <linux/fs.h>
242#include <linux/sched.h>
243
244enum jbd_state_bits {
245 BH_JBD /* Has an attached ext3 journal_head */
246 = BH_PrivateStart,
247 BH_JWrite, /* Being written to log (@@@ DEBUGGING) */
248 BH_Freed, /* Has been freed (truncated) */
249 BH_Revoked, /* Has been revoked from the log */
250 BH_RevokeValid, /* Revoked flag is valid */
251 BH_JBDDirty, /* Is dirty but journaled */
252 BH_State, /* Pins most journal_head state */
253 BH_JournalHead, /* Pins bh->b_private and jh->b_bh */
254 BH_Unshadow, /* Dummy bit, for BJ_Shadow wakeup filtering */
255 BH_JBDPrivateStart, /* First bit available for private use by FS */
256};
257
258BUFFER_FNS(JBD, jbd)
259BUFFER_FNS(JWrite, jwrite)
260BUFFER_FNS(JBDDirty, jbddirty)
261TAS_BUFFER_FNS(JBDDirty, jbddirty)
262BUFFER_FNS(Revoked, revoked)
263TAS_BUFFER_FNS(Revoked, revoked)
264BUFFER_FNS(RevokeValid, revokevalid)
265TAS_BUFFER_FNS(RevokeValid, revokevalid)
266BUFFER_FNS(Freed, freed)
267
268#include <linux/jbd_common.h>
269
270#define J_ASSERT(assert) BUG_ON(!(assert))
271
272#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
273#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
274
275#if defined(JBD_PARANOID_IOFAIL)
276#define J_EXPECT(expr, why...) J_ASSERT(expr)
277#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
278#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
279#else
280#define __journal_expect(expr, why...) \
281 ({ \
282 int val = (expr); \
283 if (!val) { \
284 printk(KERN_ERR \
285 "EXT3-fs unexpected failure: %s;\n",# expr); \
286 printk(KERN_ERR why "\n"); \
287 } \
288 val; \
289 })
290#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
291#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
292#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
293#endif
294
295struct jbd_revoke_table_s;
296
297/**
298 * struct handle_s - this is the concrete type associated with handle_t.
299 * @h_transaction: Which compound transaction is this update a part of?
300 * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
301 * @h_ref: Reference count on this handle
302 * @h_err: Field for caller's use to track errors through large fs operations
303 * @h_sync: flag for sync-on-close
304 * @h_jdata: flag to force data journaling
305 * @h_aborted: flag indicating fatal error on handle
306 * @h_lockdep_map: lockdep info for debugging lock problems
307 */
308struct handle_s
309{
310 /* Which compound transaction is this update a part of? */
311 transaction_t *h_transaction;
312
313 /* Number of remaining buffers we are allowed to dirty: */
314 int h_buffer_credits;
315
316 /* Reference count on this handle */
317 int h_ref;
318
319 /* Field for caller's use to track errors through large fs */
320 /* operations */
321 int h_err;
322
323 /* Flags [no locking] */
324 unsigned int h_sync: 1; /* sync-on-close */
325 unsigned int h_jdata: 1; /* force data journaling */
326 unsigned int h_aborted: 1; /* fatal error on handle */
327
328#ifdef CONFIG_DEBUG_LOCK_ALLOC
329 struct lockdep_map h_lockdep_map;
330#endif
331};
332
333
334/* The transaction_t type is the guts of the journaling mechanism. It
335 * tracks a compound transaction through its various states:
336 *
337 * RUNNING: accepting new updates
338 * LOCKED: Updates still running but we don't accept new ones
339 * RUNDOWN: Updates are tidying up but have finished requesting
340 * new buffers to modify (state not used for now)
341 * FLUSH: All updates complete, but we are still writing to disk
342 * COMMIT: All data on disk, writing commit record
343 * FINISHED: We still have to keep the transaction for checkpointing.
344 *
345 * The transaction keeps track of all of the buffers modified by a
346 * running transaction, and all of the buffers committed but not yet
347 * flushed to home for finished transactions.
348 */
349
350/*
351 * Lock ranking:
352 *
353 * j_list_lock
354 * ->jbd_lock_bh_journal_head() (This is "innermost")
355 *
356 * j_state_lock
357 * ->jbd_lock_bh_state()
358 *
359 * jbd_lock_bh_state()
360 * ->j_list_lock
361 *
362 * j_state_lock
363 * ->t_handle_lock
364 *
365 * j_state_lock
366 * ->j_list_lock (journal_unmap_buffer)
367 *
368 */
369
370struct transaction_s
371{
372 /* Pointer to the journal for this transaction. [no locking] */
373 journal_t *t_journal;
374
375 /* Sequence number for this transaction [no locking] */
376 tid_t t_tid;
377
378 /*
379 * Transaction's current state
380 * [no locking - only kjournald alters this]
381 * [j_list_lock] guards transition of a transaction into T_FINISHED
382 * state and subsequent call of __journal_drop_transaction()
383 * FIXME: needs barriers
384 * KLUDGE: [use j_state_lock]
385 */
386 enum {
387 T_RUNNING,
388 T_LOCKED,
389 T_FLUSH,
390 T_COMMIT,
391 T_COMMIT_RECORD,
392 T_FINISHED
393 } t_state;
394
395 /*
396 * Where in the log does this transaction's commit start? [no locking]
397 */
398 unsigned int t_log_start;
399
400 /* Number of buffers on the t_buffers list [j_list_lock] */
401 int t_nr_buffers;
402
403 /*
404 * Doubly-linked circular list of all buffers reserved but not yet
405 * modified by this transaction [j_list_lock]
406 */
407 struct journal_head *t_reserved_list;
408
409 /*
410 * Doubly-linked circular list of all buffers under writeout during
411 * commit [j_list_lock]
412 */
413 struct journal_head *t_locked_list;
414
415 /*
416 * Doubly-linked circular list of all metadata buffers owned by this
417 * transaction [j_list_lock]
418 */
419 struct journal_head *t_buffers;
420
421 /*
422 * Doubly-linked circular list of all data buffers still to be
423 * flushed before this transaction can be committed [j_list_lock]
424 */
425 struct journal_head *t_sync_datalist;
426
427 /*
428 * Doubly-linked circular list of all forget buffers (superseded
429 * buffers which we can un-checkpoint once this transaction commits)
430 * [j_list_lock]
431 */
432 struct journal_head *t_forget;
433
434 /*
435 * Doubly-linked circular list of all buffers still to be flushed before
436 * this transaction can be checkpointed. [j_list_lock]
437 */
438 struct journal_head *t_checkpoint_list;
439
440 /*
441 * Doubly-linked circular list of all buffers submitted for IO while
442 * checkpointing. [j_list_lock]
443 */
444 struct journal_head *t_checkpoint_io_list;
445
446 /*
447 * Doubly-linked circular list of temporary buffers currently undergoing
448 * IO in the log [j_list_lock]
449 */
450 struct journal_head *t_iobuf_list;
451
452 /*
453 * Doubly-linked circular list of metadata buffers being shadowed by log
454 * IO. The IO buffers on the iobuf list and the shadow buffers on this
455 * list match each other one for one at all times. [j_list_lock]
456 */
457 struct journal_head *t_shadow_list;
458
459 /*
460 * Doubly-linked circular list of control buffers being written to the
461 * log. [j_list_lock]
462 */
463 struct journal_head *t_log_list;
464
465 /*
466 * Protects info related to handles
467 */
468 spinlock_t t_handle_lock;
469
470 /*
471 * Number of outstanding updates running on this transaction
472 * [t_handle_lock]
473 */
474 int t_updates;
475
476 /*
477 * Number of buffers reserved for use by all handles in this transaction
478 * handle but not yet modified. [t_handle_lock]
479 */
480 int t_outstanding_credits;
481
482 /*
483 * Forward and backward links for the circular list of all transactions
484 * awaiting checkpoint. [j_list_lock]
485 */
486 transaction_t *t_cpnext, *t_cpprev;
487
488 /*
489 * When will the transaction expire (become due for commit), in jiffies?
490 * [no locking]
491 */
492 unsigned long t_expires;
493
494 /*
495 * When this transaction started, in nanoseconds [no locking]
496 */
497 ktime_t t_start_time;
498
499 /*
500 * How many handles used this transaction? [t_handle_lock]
501 */
502 int t_handle_count;
503};
504
505/**
506 * struct journal_s - this is the concrete type associated with journal_t.
507 * @j_flags: General journaling state flags
508 * @j_errno: Is there an outstanding uncleared error on the journal (from a
509 * prior abort)?
510 * @j_sb_buffer: First part of superblock buffer
511 * @j_superblock: Second part of superblock buffer
512 * @j_format_version: Version of the superblock format
513 * @j_state_lock: Protect the various scalars in the journal
514 * @j_barrier_count: Number of processes waiting to create a barrier lock
515 * @j_running_transaction: The current running transaction..
516 * @j_committing_transaction: the transaction we are pushing to disk
517 * @j_checkpoint_transactions: a linked circular list of all transactions
518 * waiting for checkpointing
519 * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
520 * to start committing, or for a barrier lock to be released
521 * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
522 * @j_wait_done_commit: Wait queue for waiting for commit to complete
523 * @j_wait_checkpoint: Wait queue to trigger checkpointing
524 * @j_wait_commit: Wait queue to trigger commit
525 * @j_wait_updates: Wait queue to wait for updates to complete
526 * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
527 * @j_head: Journal head - identifies the first unused block in the journal
528 * @j_tail: Journal tail - identifies the oldest still-used block in the
529 * journal.
530 * @j_free: Journal free - how many free blocks are there in the journal?
531 * @j_first: The block number of the first usable block
532 * @j_last: The block number one beyond the last usable block
533 * @j_dev: Device where we store the journal
534 * @j_blocksize: blocksize for the location where we store the journal.
535 * @j_blk_offset: starting block offset for into the device where we store the
536 * journal
537 * @j_fs_dev: Device which holds the client fs. For internal journal this will
538 * be equal to j_dev
539 * @j_maxlen: Total maximum capacity of the journal region on disk.
540 * @j_list_lock: Protects the buffer lists and internal buffer state.
541 * @j_inode: Optional inode where we store the journal. If present, all journal
542 * block numbers are mapped into this inode via bmap().
543 * @j_tail_sequence: Sequence number of the oldest transaction in the log
544 * @j_transaction_sequence: Sequence number of the next transaction to grant
545 * @j_commit_sequence: Sequence number of the most recently committed
546 * transaction
547 * @j_commit_request: Sequence number of the most recent transaction wanting
548 * commit
549 * @j_commit_waited: Sequence number of the most recent transaction someone
550 * is waiting for to commit.
551 * @j_uuid: Uuid of client object.
552 * @j_task: Pointer to the current commit thread for this journal
553 * @j_max_transaction_buffers: Maximum number of metadata buffers to allow in a
554 * single compound commit transaction
555 * @j_commit_interval: What is the maximum transaction lifetime before we begin
556 * a commit?
557 * @j_commit_timer: The timer used to wakeup the commit thread
558 * @j_revoke_lock: Protect the revoke table
559 * @j_revoke: The revoke table - maintains the list of revoked blocks in the
560 * current transaction.
561 * @j_revoke_table: alternate revoke tables for j_revoke
562 * @j_wbuf: array of buffer_heads for journal_commit_transaction
563 * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
564 * number that will fit in j_blocksize
565 * @j_last_sync_writer: most recent pid which did a synchronous write
566 * @j_average_commit_time: the average amount of time in nanoseconds it
567 * takes to commit a transaction to the disk.
568 * @j_private: An opaque pointer to fs-private information.
569 */
570
571struct journal_s
572{
573 /* General journaling state flags [j_state_lock] */
574 unsigned long j_flags;
575
576 /*
577 * Is there an outstanding uncleared error on the journal (from a prior
578 * abort)? [j_state_lock]
579 */
580 int j_errno;
581
582 /* The superblock buffer */
583 struct buffer_head *j_sb_buffer;
584 journal_superblock_t *j_superblock;
585
586 /* Version of the superblock format */
587 int j_format_version;
588
589 /*
590 * Protect the various scalars in the journal
591 */
592 spinlock_t j_state_lock;
593
594 /*
595 * Number of processes waiting to create a barrier lock [j_state_lock]
596 */
597 int j_barrier_count;
598
599 /*
600 * Transactions: The current running transaction...
601 * [j_state_lock] [caller holding open handle]
602 */
603 transaction_t *j_running_transaction;
604
605 /*
606 * the transaction we are pushing to disk
607 * [j_state_lock] [caller holding open handle]
608 */
609 transaction_t *j_committing_transaction;
610
611 /*
612 * ... and a linked circular list of all transactions waiting for
613 * checkpointing. [j_list_lock]
614 */
615 transaction_t *j_checkpoint_transactions;
616
617 /*
618 * Wait queue for waiting for a locked transaction to start committing,
619 * or for a barrier lock to be released
620 */
621 wait_queue_head_t j_wait_transaction_locked;
622
623 /* Wait queue for waiting for checkpointing to complete */
624 wait_queue_head_t j_wait_logspace;
625
626 /* Wait queue for waiting for commit to complete */
627 wait_queue_head_t j_wait_done_commit;
628
629 /* Wait queue to trigger checkpointing */
630 wait_queue_head_t j_wait_checkpoint;
631
632 /* Wait queue to trigger commit */
633 wait_queue_head_t j_wait_commit;
634
635 /* Wait queue to wait for updates to complete */
636 wait_queue_head_t j_wait_updates;
637
638 /* Semaphore for locking against concurrent checkpoints */
639 struct mutex j_checkpoint_mutex;
640
641 /*
642 * Journal head: identifies the first unused block in the journal.
643 * [j_state_lock]
644 */
645 unsigned int j_head;
646
647 /*
648 * Journal tail: identifies the oldest still-used block in the journal.
649 * [j_state_lock]
650 */
651 unsigned int j_tail;
652
653 /*
654 * Journal free: how many free blocks are there in the journal?
655 * [j_state_lock]
656 */
657 unsigned int j_free;
658
659 /*
660 * Journal start and end: the block numbers of the first usable block
661 * and one beyond the last usable block in the journal. [j_state_lock]
662 */
663 unsigned int j_first;
664 unsigned int j_last;
665
666 /*
667 * Device, blocksize and starting block offset for the location where we
668 * store the journal.
669 */
670 struct block_device *j_dev;
671 int j_blocksize;
672 unsigned int j_blk_offset;
673
674 /*
675 * Device which holds the client fs. For internal journal this will be
676 * equal to j_dev.
677 */
678 struct block_device *j_fs_dev;
679
680 /* Total maximum capacity of the journal region on disk. */
681 unsigned int j_maxlen;
682
683 /*
684 * Protects the buffer lists and internal buffer state.
685 */
686 spinlock_t j_list_lock;
687
688 /* Optional inode where we store the journal. If present, all */
689 /* journal block numbers are mapped into this inode via */
690 /* bmap(). */
691 struct inode *j_inode;
692
693 /*
694 * Sequence number of the oldest transaction in the log [j_state_lock]
695 */
696 tid_t j_tail_sequence;
697
698 /*
699 * Sequence number of the next transaction to grant [j_state_lock]
700 */
701 tid_t j_transaction_sequence;
702
703 /*
704 * Sequence number of the most recently committed transaction
705 * [j_state_lock].
706 */
707 tid_t j_commit_sequence;
708
709 /*
710 * Sequence number of the most recent transaction wanting commit
711 * [j_state_lock]
712 */
713 tid_t j_commit_request;
714
715 /*
716 * Sequence number of the most recent transaction someone is waiting
717 * for to commit.
718 * [j_state_lock]
719 */
720 tid_t j_commit_waited;
721
722 /*
723 * Journal uuid: identifies the object (filesystem, LVM volume etc)
724 * backed by this journal. This will eventually be replaced by an array
725 * of uuids, allowing us to index multiple devices within a single
726 * journal and to perform atomic updates across them.
727 */
728 __u8 j_uuid[16];
729
730 /* Pointer to the current commit thread for this journal */
731 struct task_struct *j_task;
732
733 /*
734 * Maximum number of metadata buffers to allow in a single compound
735 * commit transaction
736 */
737 int j_max_transaction_buffers;
738
739 /*
740 * What is the maximum transaction lifetime before we begin a commit?
741 */
742 unsigned long j_commit_interval;
743
744 /* The timer used to wakeup the commit thread: */
745 struct timer_list j_commit_timer;
746
747 /*
748 * The revoke table: maintains the list of revoked blocks in the
749 * current transaction. [j_revoke_lock]
750 */
751 spinlock_t j_revoke_lock;
752 struct jbd_revoke_table_s *j_revoke;
753 struct jbd_revoke_table_s *j_revoke_table[2];
754
755 /*
756 * array of bhs for journal_commit_transaction
757 */
758 struct buffer_head **j_wbuf;
759 int j_wbufsize;
760
761 /*
762 * this is the pid of the last person to run a synchronous operation
763 * through the journal.
764 */
765 pid_t j_last_sync_writer;
766
767 /*
768 * the average amount of time in nanoseconds it takes to commit a
769 * transaction to the disk. [j_state_lock]
770 */
771 u64 j_average_commit_time;
772
773 /*
774 * An opaque pointer to fs-private information. ext3 puts its
775 * superblock pointer here
776 */
777 void *j_private;
778};
779
780/*
781 * Journal flag definitions
782 */
783#define JFS_UNMOUNT 0x001 /* Journal thread is being destroyed */
784#define JFS_ABORT 0x002 /* Journaling has been aborted for errors. */
785#define JFS_ACK_ERR 0x004 /* The errno in the sb has been acked */
786#define JFS_FLUSHED 0x008 /* The journal superblock has been flushed */
787#define JFS_LOADED 0x010 /* The journal superblock has been loaded */
788#define JFS_BARRIER 0x020 /* Use IDE barriers */
789#define JFS_ABORT_ON_SYNCDATA_ERR 0x040 /* Abort the journal on file
790 * data write error in ordered
791 * mode */
792
793/*
794 * Function declarations for the journaling transaction and buffer
795 * management
796 */
797
798/* Filing buffers */
799extern void journal_unfile_buffer(journal_t *, struct journal_head *);
800extern void __journal_unfile_buffer(struct journal_head *);
801extern void __journal_refile_buffer(struct journal_head *);
802extern void journal_refile_buffer(journal_t *, struct journal_head *);
803extern void __journal_file_buffer(struct journal_head *, transaction_t *, int);
804extern void __journal_free_buffer(struct journal_head *bh);
805extern void journal_file_buffer(struct journal_head *, transaction_t *, int);
806extern void __journal_clean_data_list(transaction_t *transaction);
807
808/* Log buffer allocation */
809extern struct journal_head * journal_get_descriptor_buffer(journal_t *);
810int journal_next_log_block(journal_t *, unsigned int *);
811
812/* Commit management */
813extern void journal_commit_transaction(journal_t *);
814
815/* Checkpoint list management */
816int __journal_clean_checkpoint_list(journal_t *journal);
817int __journal_remove_checkpoint(struct journal_head *);
818void __journal_insert_checkpoint(struct journal_head *, transaction_t *);
819
820/* Buffer IO */
821extern int
822journal_write_metadata_buffer(transaction_t *transaction,
823 struct journal_head *jh_in,
824 struct journal_head **jh_out,
825 unsigned int blocknr);
826
827/* Transaction locking */
828extern void __wait_on_journal (journal_t *);
829
830/*
831 * Journal locking.
832 *
833 * We need to lock the journal during transaction state changes so that nobody
834 * ever tries to take a handle on the running transaction while we are in the
835 * middle of moving it to the commit phase. j_state_lock does this.
836 *
837 * Note that the locking is completely interrupt unsafe. We never touch
838 * journal structures from interrupts.
839 */
840
841static inline handle_t *journal_current_handle(void)
842{
843 return current->journal_info;
844}
845
846/* The journaling code user interface:
847 *
848 * Create and destroy handles
849 * Register buffer modifications against the current transaction.
850 */
851
852extern handle_t *journal_start(journal_t *, int nblocks);
853extern int journal_restart (handle_t *, int nblocks);
854extern int journal_extend (handle_t *, int nblocks);
855extern int journal_get_write_access(handle_t *, struct buffer_head *);
856extern int journal_get_create_access (handle_t *, struct buffer_head *);
857extern int journal_get_undo_access(handle_t *, struct buffer_head *);
858extern int journal_dirty_data (handle_t *, struct buffer_head *);
859extern int journal_dirty_metadata (handle_t *, struct buffer_head *);
860extern void journal_release_buffer (handle_t *, struct buffer_head *);
861extern int journal_forget (handle_t *, struct buffer_head *);
862extern void journal_sync_buffer (struct buffer_head *);
863extern void journal_invalidatepage(journal_t *,
864 struct page *, unsigned int, unsigned int);
865extern int journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
866extern int journal_stop(handle_t *);
867extern int journal_flush (journal_t *);
868extern void journal_lock_updates (journal_t *);
869extern void journal_unlock_updates (journal_t *);
870
871extern journal_t * journal_init_dev(struct block_device *bdev,
872 struct block_device *fs_dev,
873 int start, int len, int bsize);
874extern journal_t * journal_init_inode (struct inode *);
875extern int journal_update_format (journal_t *);
876extern int journal_check_used_features
877 (journal_t *, unsigned long, unsigned long, unsigned long);
878extern int journal_check_available_features
879 (journal_t *, unsigned long, unsigned long, unsigned long);
880extern int journal_set_features
881 (journal_t *, unsigned long, unsigned long, unsigned long);
882extern int journal_create (journal_t *);
883extern int journal_load (journal_t *journal);
884extern int journal_destroy (journal_t *);
885extern int journal_recover (journal_t *journal);
886extern int journal_wipe (journal_t *, int);
887extern int journal_skip_recovery (journal_t *);
888extern void journal_update_sb_log_tail (journal_t *, tid_t, unsigned int,
889 int);
890extern void journal_abort (journal_t *, int);
891extern int journal_errno (journal_t *);
892extern void journal_ack_err (journal_t *);
893extern int journal_clear_err (journal_t *);
894extern int journal_bmap(journal_t *, unsigned int, unsigned int *);
895extern int journal_force_commit(journal_t *);
896
897/*
898 * journal_head management
899 */
900struct journal_head *journal_add_journal_head(struct buffer_head *bh);
901struct journal_head *journal_grab_journal_head(struct buffer_head *bh);
902void journal_put_journal_head(struct journal_head *jh);
903
904/*
905 * handle management
906 */
907extern struct kmem_cache *jbd_handle_cache;
908
909static inline handle_t *jbd_alloc_handle(gfp_t gfp_flags)
910{
911 return kmem_cache_zalloc(jbd_handle_cache, gfp_flags);
912}
913
914static inline void jbd_free_handle(handle_t *handle)
915{
916 kmem_cache_free(jbd_handle_cache, handle);
917}
918
919/* Primary revoke support */
920#define JOURNAL_REVOKE_DEFAULT_HASH 256
921extern int journal_init_revoke(journal_t *, int);
922extern void journal_destroy_revoke_caches(void);
923extern int journal_init_revoke_caches(void);
924
925extern void journal_destroy_revoke(journal_t *);
926extern int journal_revoke (handle_t *,
927 unsigned int, struct buffer_head *);
928extern int journal_cancel_revoke(handle_t *, struct journal_head *);
929extern void journal_write_revoke_records(journal_t *,
930 transaction_t *, int);
931
932/* Recovery revoke support */
933extern int journal_set_revoke(journal_t *, unsigned int, tid_t);
934extern int journal_test_revoke(journal_t *, unsigned int, tid_t);
935extern void journal_clear_revoke(journal_t *);
936extern void journal_switch_revoke_table(journal_t *journal);
937extern void journal_clear_buffer_revoked_flags(journal_t *journal);
938
939/*
940 * The log thread user interface:
941 *
942 * Request space in the current transaction, and force transaction commit
943 * transitions on demand.
944 */
945
946int __log_space_left(journal_t *); /* Called with journal locked */
947int log_start_commit(journal_t *journal, tid_t tid);
948int __log_start_commit(journal_t *journal, tid_t tid);
949int journal_start_commit(journal_t *journal, tid_t *tid);
950int journal_force_commit_nested(journal_t *journal);
951int log_wait_commit(journal_t *journal, tid_t tid);
952int log_do_checkpoint(journal_t *journal);
953int journal_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
954
955void __log_wait_for_space(journal_t *journal);
956extern void __journal_drop_transaction(journal_t *, transaction_t *);
957extern int cleanup_journal_tail(journal_t *);
958
959/*
960 * is_journal_abort
961 *
962 * Simple test wrapper function to test the JFS_ABORT state flag. This
963 * bit, when set, indicates that we have had a fatal error somewhere,
964 * either inside the journaling layer or indicated to us by the client
965 * (eg. ext3), and that we and should not commit any further
966 * transactions.
967 */
968
969static inline int is_journal_aborted(journal_t *journal)
970{
971 return journal->j_flags & JFS_ABORT;
972}
973
974static inline int is_handle_aborted(handle_t *handle)
975{
976 if (handle->h_aborted)
977 return 1;
978 return is_journal_aborted(handle->h_transaction->t_journal);
979}
980
981static inline void journal_abort_handle(handle_t *handle)
982{
983 handle->h_aborted = 1;
984}
985
986#endif /* __KERNEL__ */
987
988/* Comparison functions for transaction IDs: perform comparisons using
989 * modulo arithmetic so that they work over sequence number wraps. */
990
991static inline int tid_gt(tid_t x, tid_t y)
992{
993 int difference = (x - y);
994 return (difference > 0);
995}
996
997static inline int tid_geq(tid_t x, tid_t y)
998{
999 int difference = (x - y);
1000 return (difference >= 0);
1001}
1002
1003extern int journal_blocks_per_page(struct inode *inode);
1004
1005/*
1006 * Return the minimum number of blocks which must be free in the journal
1007 * before a new transaction may be started. Must be called under j_state_lock.
1008 */
1009static inline int jbd_space_needed(journal_t *journal)
1010{
1011 int nblocks = journal->j_max_transaction_buffers;
1012 if (journal->j_committing_transaction)
1013 nblocks += journal->j_committing_transaction->
1014 t_outstanding_credits;
1015 return nblocks;
1016}
1017
1018/*
1019 * Definitions which augment the buffer_head layer
1020 */
1021
1022/* journaling buffer types */
1023#define BJ_None 0 /* Not journaled */
1024#define BJ_SyncData 1 /* Normal data: flush before commit */
1025#define BJ_Metadata 2 /* Normal journaled metadata */
1026#define BJ_Forget 3 /* Buffer superseded by this transaction */
1027#define BJ_IO 4 /* Buffer is for temporary IO use */
1028#define BJ_Shadow 5 /* Buffer contents being shadowed to the log */
1029#define BJ_LogCtl 6 /* Buffer contains log descriptors */
1030#define BJ_Reserved 7 /* Buffer is reserved for access by journal */
1031#define BJ_Locked 8 /* Locked for I/O during commit */
1032#define BJ_Types 9
1033
1034extern int jbd_blocks_per_page(struct inode *inode);
1035
1036#ifdef __KERNEL__
1037
1038#define buffer_trace_init(bh) do {} while (0)
1039#define print_buffer_fields(bh) do {} while (0)
1040#define print_buffer_trace(bh) do {} while (0)
1041#define BUFFER_TRACE(bh, info) do {} while (0)
1042#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1043#define JBUFFER_TRACE(jh, info) do {} while (0)
1044
1045#endif /* __KERNEL__ */
1046
1047#endif /* _LINUX_JBD_H */
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index edb640ae9a94..ad4b28647298 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -29,6 +29,7 @@
29#include <linux/mutex.h> 29#include <linux/mutex.h>
30#include <linux/timer.h> 30#include <linux/timer.h>
31#include <linux/slab.h> 31#include <linux/slab.h>
32#include <linux/bit_spinlock.h>
32#include <crypto/hash.h> 33#include <crypto/hash.h>
33#endif 34#endif
34 35
@@ -336,7 +337,45 @@ BUFFER_FNS(Freed, freed)
336BUFFER_FNS(Shadow, shadow) 337BUFFER_FNS(Shadow, shadow)
337BUFFER_FNS(Verified, verified) 338BUFFER_FNS(Verified, verified)
338 339
339#include <linux/jbd_common.h> 340static inline struct buffer_head *jh2bh(struct journal_head *jh)
341{
342 return jh->b_bh;
343}
344
345static inline struct journal_head *bh2jh(struct buffer_head *bh)
346{
347 return bh->b_private;
348}
349
350static inline void jbd_lock_bh_state(struct buffer_head *bh)
351{
352 bit_spin_lock(BH_State, &bh->b_state);
353}
354
355static inline int jbd_trylock_bh_state(struct buffer_head *bh)
356{
357 return bit_spin_trylock(BH_State, &bh->b_state);
358}
359
360static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
361{
362 return bit_spin_is_locked(BH_State, &bh->b_state);
363}
364
365static inline void jbd_unlock_bh_state(struct buffer_head *bh)
366{
367 bit_spin_unlock(BH_State, &bh->b_state);
368}
369
370static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
371{
372 bit_spin_lock(BH_JournalHead, &bh->b_state);
373}
374
375static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
376{
377 bit_spin_unlock(BH_JournalHead, &bh->b_state);
378}
340 379
341#define J_ASSERT(assert) BUG_ON(!(assert)) 380#define J_ASSERT(assert) BUG_ON(!(assert))
342 381
diff --git a/include/linux/jbd_common.h b/include/linux/jbd_common.h
deleted file mode 100644
index 3dc53432355f..000000000000
--- a/include/linux/jbd_common.h
+++ /dev/null
@@ -1,46 +0,0 @@
1#ifndef _LINUX_JBD_STATE_H
2#define _LINUX_JBD_STATE_H
3
4#include <linux/bit_spinlock.h>
5
6static inline struct buffer_head *jh2bh(struct journal_head *jh)
7{
8 return jh->b_bh;
9}
10
11static inline struct journal_head *bh2jh(struct buffer_head *bh)
12{
13 return bh->b_private;
14}
15
16static inline void jbd_lock_bh_state(struct buffer_head *bh)
17{
18 bit_spin_lock(BH_State, &bh->b_state);
19}
20
21static inline int jbd_trylock_bh_state(struct buffer_head *bh)
22{
23 return bit_spin_trylock(BH_State, &bh->b_state);
24}
25
26static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
27{
28 return bit_spin_is_locked(BH_State, &bh->b_state);
29}
30
31static inline void jbd_unlock_bh_state(struct buffer_head *bh)
32{
33 bit_spin_unlock(BH_State, &bh->b_state);
34}
35
36static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
37{
38 bit_spin_lock(BH_JournalHead, &bh->b_state);
39}
40
41static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
42{
43 bit_spin_unlock(BH_JournalHead, &bh->b_state);
44}
45
46#endif
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 77ca6601ff25..7a57c28eb5e7 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -43,7 +43,7 @@ void inode_claim_rsv_space(struct inode *inode, qsize_t number);
43void inode_sub_rsv_space(struct inode *inode, qsize_t number); 43void inode_sub_rsv_space(struct inode *inode, qsize_t number);
44void inode_reclaim_rsv_space(struct inode *inode, qsize_t number); 44void inode_reclaim_rsv_space(struct inode *inode, qsize_t number);
45 45
46void dquot_initialize(struct inode *inode); 46int dquot_initialize(struct inode *inode);
47void dquot_drop(struct inode *inode); 47void dquot_drop(struct inode *inode);
48struct dquot *dqget(struct super_block *sb, struct kqid qid); 48struct dquot *dqget(struct super_block *sb, struct kqid qid);
49static inline struct dquot *dqgrab(struct dquot *dquot) 49static inline struct dquot *dqgrab(struct dquot *dquot)
@@ -200,8 +200,9 @@ static inline int sb_has_quota_active(struct super_block *sb, int type)
200 return 0; 200 return 0;
201} 201}
202 202
203static inline void dquot_initialize(struct inode *inode) 203static inline int dquot_initialize(struct inode *inode)
204{ 204{
205 return 0;
205} 206}
206 207
207static inline void dquot_drop(struct inode *inode) 208static inline void dquot_drop(struct inode *inode)
generated by cgit v1.2.2 (git 2.25.0) at 2026-01-06 15:41:44 -0500