1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
5 */
6
7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
9#include <linux/spinlock.h>
10#include <linux/completion.h>
11#include <linux/buffer_head.h>
12#include <linux/kthread.h>
13#include <linux/crc32.h>
14#include <linux/gfs2_ondisk.h>
15#include <linux/delay.h>
16#include <linux/uaccess.h>
17
18#include "gfs2.h"
19#include "incore.h"
20#include "glock.h"
21#include "glops.h"
22#include "log.h"
23#include "lops.h"
24#include "recovery.h"
25#include "rgrp.h"
26#include "super.h"
27#include "util.h"
28
29struct kmem_cache *gfs2_glock_cachep __read_mostly;
30struct kmem_cache *gfs2_glock_aspace_cachep __read_mostly;
31struct kmem_cache *gfs2_inode_cachep __read_mostly;
32struct kmem_cache *gfs2_bufdata_cachep __read_mostly;
33struct kmem_cache *gfs2_rgrpd_cachep __read_mostly;
34struct kmem_cache *gfs2_quotad_cachep __read_mostly;
35struct kmem_cache *gfs2_qadata_cachep __read_mostly;
36struct kmem_cache *gfs2_trans_cachep __read_mostly;
37mempool_t *gfs2_page_pool __read_mostly;
38
39void gfs2_assert_i(struct gfs2_sbd *sdp)
40{
41 fs_emerg(sdp, "fatal assertion failed\n");
42}
43
44/**
45 * check_journal_clean - Make sure a journal is clean for a spectator mount
46 * @sdp: The GFS2 superblock
47 * @jd: The journal descriptor
48 * @verbose: Show more prints in the log
49 *
50 * Returns: 0 if the journal is clean or locked, else an error
51 */
52int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
53 bool verbose)
54{
55 int error;
56 struct gfs2_holder j_gh;
57 struct gfs2_log_header_host head;
58 struct gfs2_inode *ip;
59
60 ip = GFS2_I(inode: jd->jd_inode);
61 error = gfs2_glock_nq_init(gl: ip->i_gl, LM_ST_SHARED, LM_FLAG_RECOVER |
62 GL_EXACT | GL_NOCACHE, gh: &j_gh);
63 if (error) {
64 if (verbose)
65 fs_err(sdp, "Error %d locking journal for spectator "
66 "mount.\n", error);
67 return -EPERM;
68 }
69 error = gfs2_jdesc_check(jd);
70 if (error) {
71 if (verbose)
72 fs_err(sdp, "Error checking journal for spectator "
73 "mount.\n");
74 goto out_unlock;
75 }
76 error = gfs2_find_jhead(jd, head: &head);
77 if (error) {
78 if (verbose)
79 fs_err(sdp, "Error parsing journal for spectator "
80 "mount.\n");
81 goto out_unlock;
82 }
83 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
84 error = -EPERM;
85 if (verbose)
86 fs_err(sdp, "jid=%u: Journal is dirty, so the first "
87 "mounter must not be a spectator.\n",
88 jd->jd_jid);
89 }
90
91out_unlock:
92 gfs2_glock_dq_uninit(gh: &j_gh);
93 return error;
94}
95
96/**
97 * gfs2_freeze_lock_shared - hold the freeze glock
98 * @sdp: the superblock
99 */
100int gfs2_freeze_lock_shared(struct gfs2_sbd *sdp)
101{
102 int flags = LM_FLAG_RECOVER | GL_EXACT;
103 int error;
104
105 error = gfs2_glock_nq_init(gl: sdp->sd_freeze_gl, LM_ST_SHARED, flags,
106 gh: &sdp->sd_freeze_gh);
107 if (error && error != GLR_TRYFAILED)
108 fs_err(sdp, "can't lock the freeze glock: %d\n", error);
109 return error;
110}
111
112void gfs2_freeze_unlock(struct gfs2_sbd *sdp)
113{
114 if (gfs2_holder_initialized(gh: &sdp->sd_freeze_gh))
115 gfs2_glock_dq_uninit(gh: &sdp->sd_freeze_gh);
116}
117
118static void do_withdraw(struct gfs2_sbd *sdp)
119{
120 down_write(sem: &sdp->sd_log_flush_lock);
121 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
122 up_write(sem: &sdp->sd_log_flush_lock);
123 return;
124 }
125 clear_bit(nr: SDF_JOURNAL_LIVE, addr: &sdp->sd_flags);
126 up_write(sem: &sdp->sd_log_flush_lock);
127
128 gfs2_ail_drain(sdp); /* frees all transactions */
129
130 wake_up(&sdp->sd_logd_waitq);
131 wake_up(&sdp->sd_quota_wait);
132
133 wait_event_timeout(sdp->sd_log_waitq,
134 gfs2_log_is_empty(sdp),
135 HZ * 5);
136
137 sdp->sd_vfs->s_flags |= SB_RDONLY;
138
139 /*
140 * Dequeue any pending non-system glock holders that can no
141 * longer be granted because the file system is withdrawn.
142 */
143 gfs2_withdraw_glocks(sdp);
144}
145
146void gfs2_lm(struct gfs2_sbd *sdp, const char *fmt, ...)
147{
148 struct va_format vaf;
149 va_list args;
150
151 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW &&
152 test_bit(SDF_WITHDRAWN, &sdp->sd_flags))
153 return;
154
155 va_start(args, fmt);
156 vaf.fmt = fmt;
157 vaf.va = &args;
158 fs_err(sdp, "%pV", &vaf);
159 va_end(args);
160}
161
162/**
163 * gfs2_offline_uevent - run gfs2_withdraw_helper
164 * @sdp: The GFS2 superblock
165 */
166static bool gfs2_offline_uevent(struct gfs2_sbd *sdp)
167{
168 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
169 long timeout;
170
171 /* Skip protocol "lock_nolock" which doesn't require shared storage. */
172 if (!ls->ls_ops->lm_lock)
173 return false;
174
175 /*
176 * The gfs2_withdraw_helper replies by writing one of the following
177 * status codes to "/sys$DEVPATH/lock_module/withdraw":
178 *
179 * 0 - The shared block device has been marked inactive. Future write
180 * operations will fail.
181 *
182 * 1 - The shared block device may still be active and carry out
183 * write operations.
184 *
185 * If the "offline" uevent isn't reacted upon in time, the event
186 * handler is assumed to have failed.
187 */
188
189 sdp->sd_withdraw_helper_status = -1;
190 kobject_uevent(kobj: &sdp->sd_kobj, action: KOBJ_OFFLINE);
191 timeout = gfs2_tune_get(sdp, gt_withdraw_helper_timeout) * HZ;
192 wait_for_completion_timeout(x: &sdp->sd_withdraw_helper, timeout);
193 if (sdp->sd_withdraw_helper_status == -1) {
194 fs_err(sdp, "%s timed out\n", "gfs2_withdraw_helper");
195 } else {
196 fs_err(sdp, "%s %s with status %d\n",
197 "gfs2_withdraw_helper",
198 sdp->sd_withdraw_helper_status == 0 ?
199 "succeeded" : "failed",
200 sdp->sd_withdraw_helper_status);
201 }
202 return sdp->sd_withdraw_helper_status == 0;
203}
204
205void gfs2_withdraw_func(struct work_struct *work)
206{
207 struct gfs2_sbd *sdp = container_of(work, struct gfs2_sbd, sd_withdraw_work);
208 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
209 const struct lm_lockops *lm = ls->ls_ops;
210 bool device_inactive;
211
212 if (test_bit(SDF_KILL, &sdp->sd_flags))
213 return;
214
215 BUG_ON(sdp->sd_args.ar_debug);
216
217 /*
218 * Try to deactivate the shared block device so that no more I/O will
219 * go through. If successful, we can immediately trigger remote
220 * recovery. Otherwise, we must first empty out all our local caches.
221 */
222
223 device_inactive = gfs2_offline_uevent(sdp);
224
225 if (sdp->sd_args.ar_errors == GFS2_ERRORS_DEACTIVATE && !device_inactive)
226 panic(fmt: "GFS2: fsid=%s: panic requested\n", sdp->sd_fsname);
227
228 if (lm->lm_unmount) {
229 if (device_inactive) {
230 lm->lm_unmount(sdp, false);
231 do_withdraw(sdp);
232 } else {
233 do_withdraw(sdp);
234 lm->lm_unmount(sdp, false);
235 }
236 } else {
237 do_withdraw(sdp);
238 }
239
240 fs_err(sdp, "file system withdrawn\n");
241}
242
243void gfs2_withdraw(struct gfs2_sbd *sdp)
244{
245 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW ||
246 sdp->sd_args.ar_errors == GFS2_ERRORS_DEACTIVATE) {
247 if (test_and_set_bit(nr: SDF_WITHDRAWN, addr: &sdp->sd_flags))
248 return;
249
250 dump_stack();
251 /*
252 * There is no need to withdraw when the superblock hasn't been
253 * fully initialized, yet.
254 */
255 if (!(sdp->sd_vfs->s_flags & SB_BORN))
256 return;
257 fs_err(sdp, "about to withdraw this file system\n");
258 schedule_work(work: &sdp->sd_withdraw_work);
259 return;
260 }
261
262 if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
263 panic(fmt: "GFS2: fsid=%s: panic requested\n", sdp->sd_fsname);
264}
265
266/*
267 * gfs2_assert_withdraw_i - Cause the machine to withdraw if @assertion is false
268 */
269
270void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
271 const char *function, char *file, unsigned int line)
272{
273 if (gfs2_withdrawn(sdp))
274 return;
275
276 fs_err(sdp,
277 "fatal: assertion \"%s\" failed - "
278 "function = %s, file = %s, line = %u\n",
279 assertion, function, file, line);
280
281 gfs2_withdraw(sdp);
282 dump_stack();
283}
284
285/*
286 * gfs2_assert_warn_i - Print a message to the console if @assertion is false
287 */
288
289void gfs2_assert_warn_i(struct gfs2_sbd *sdp, char *assertion,
290 const char *function, char *file, unsigned int line)
291{
292 if (time_before(jiffies,
293 sdp->sd_last_warning +
294 gfs2_tune_get(sdp, gt_complain_secs) * HZ))
295 return;
296
297 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW)
298 fs_warn(sdp, "warning: assertion \"%s\" failed - "
299 "function = %s, file = %s, line = %u\n",
300 assertion, function, file, line);
301
302 if (sdp->sd_args.ar_debug)
303 BUG();
304 else
305 dump_stack();
306
307 if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
308 panic(fmt: "GFS2: fsid=%s: warning: assertion \"%s\" failed - "
309 "function = %s, file = %s, line = %u\n",
310 sdp->sd_fsname, assertion,
311 function, file, line);
312
313 sdp->sd_last_warning = jiffies;
314}
315
316/*
317 * gfs2_consist_i - Flag a filesystem consistency error and withdraw
318 */
319
320void gfs2_consist_i(struct gfs2_sbd *sdp, const char *function,
321 char *file, unsigned int line)
322{
323 gfs2_lm(sdp,
324 fmt: "fatal: filesystem consistency error - "
325 "function = %s, file = %s, line = %u\n",
326 function, file, line);
327 gfs2_withdraw(sdp);
328}
329
330/*
331 * gfs2_consist_inode_i - Flag an inode consistency error and withdraw
332 */
333
334void gfs2_consist_inode_i(struct gfs2_inode *ip,
335 const char *function, char *file, unsigned int line)
336{
337 struct gfs2_sbd *sdp = GFS2_SB(inode: &ip->i_inode);
338
339 gfs2_lm(sdp,
340 fmt: "fatal: filesystem consistency error - "
341 "inode = %llu %llu, "
342 "function = %s, file = %s, line = %u\n",
343 (unsigned long long)ip->i_no_formal_ino,
344 (unsigned long long)ip->i_no_addr,
345 function, file, line);
346 gfs2_dump_glock(NULL, gl: ip->i_gl, fsid: 1);
347 gfs2_withdraw(sdp);
348}
349
350/*
351 * gfs2_consist_rgrpd_i - Flag a RG consistency error and withdraw
352 */
353
354void gfs2_consist_rgrpd_i(struct gfs2_rgrpd *rgd,
355 const char *function, char *file, unsigned int line)
356{
357 struct gfs2_sbd *sdp = rgd->rd_sbd;
358 char fs_id_buf[sizeof(sdp->sd_fsname) + 7];
359
360 sprintf(buf: fs_id_buf, fmt: "fsid=%s: ", sdp->sd_fsname);
361 gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
362 gfs2_lm(sdp,
363 fmt: "fatal: filesystem consistency error - "
364 "RG = %llu, "
365 "function = %s, file = %s, line = %u\n",
366 (unsigned long long)rgd->rd_addr,
367 function, file, line);
368 gfs2_dump_glock(NULL, gl: rgd->rd_gl, fsid: 1);
369 gfs2_withdraw(sdp);
370}
371
372/*
373 * gfs2_meta_check_ii - Flag a magic number consistency error and withdraw
374 */
375
376void gfs2_meta_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
377 const char *function, char *file,
378 unsigned int line)
379{
380 gfs2_lm(sdp,
381 fmt: "fatal: invalid metadata block - "
382 "bh = %llu (bad magic number), "
383 "function = %s, file = %s, line = %u\n",
384 (unsigned long long)bh->b_blocknr,
385 function, file, line);
386 gfs2_withdraw(sdp);
387}
388
389/*
390 * gfs2_metatype_check_ii - Flag a metadata type consistency error and withdraw
391 */
392
393void gfs2_metatype_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
394 u16 type, u16 t, const char *function,
395 char *file, unsigned int line)
396{
397 gfs2_lm(sdp,
398 fmt: "fatal: invalid metadata block - "
399 "bh = %llu (type: exp=%u, found=%u), "
400 "function = %s, file = %s, line = %u\n",
401 (unsigned long long)bh->b_blocknr, type, t,
402 function, file, line);
403 gfs2_withdraw(sdp);
404}
405
406/*
407 * gfs2_io_error_i - Flag an I/O error and withdraw
408 * Returns: -1 if this call withdrew the machine,
409 * 0 if it was already withdrawn
410 */
411
412void gfs2_io_error_i(struct gfs2_sbd *sdp, const char *function, char *file,
413 unsigned int line)
414{
415 gfs2_lm(sdp,
416 fmt: "fatal: I/O error - "
417 "function = %s, file = %s, line = %u\n",
418 function, file, line);
419 gfs2_withdraw(sdp);
420}
421
422/*
423 * gfs2_io_error_bh_i - Flag a buffer I/O error and withdraw
424 */
425
426void gfs2_io_error_bh_i(struct gfs2_sbd *sdp, struct buffer_head *bh,
427 const char *function, char *file, unsigned int line)
428{
429 if (gfs2_withdrawn(sdp))
430 return;
431
432 fs_err(sdp, "fatal: I/O error - "
433 "block = %llu, "
434 "function = %s, file = %s, line = %u\n",
435 (unsigned long long)bh->b_blocknr, function, file, line);
436 gfs2_withdraw(sdp);
437}
438

source code of linux/fs/gfs2/util.c