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/crc32.h>
13 #include <linux/gfs2_ondisk.h>
14 #include <linux/delay.h>
15 #include <linux/uaccess.h>
16 
17 #include "gfs2.h"
18 #include "incore.h"
19 #include "glock.h"
20 #include "glops.h"
21 #include "log.h"
22 #include "lops.h"
23 #include "recovery.h"
24 #include "rgrp.h"
25 #include "super.h"
26 #include "util.h"
27 
28 struct kmem_cache *gfs2_glock_cachep __read_mostly;
29 struct kmem_cache *gfs2_glock_aspace_cachep __read_mostly;
30 struct kmem_cache *gfs2_inode_cachep __read_mostly;
31 struct kmem_cache *gfs2_bufdata_cachep __read_mostly;
32 struct kmem_cache *gfs2_rgrpd_cachep __read_mostly;
33 struct kmem_cache *gfs2_quotad_cachep __read_mostly;
34 struct kmem_cache *gfs2_qadata_cachep __read_mostly;
35 struct kmem_cache *gfs2_trans_cachep __read_mostly;
36 mempool_t *gfs2_page_pool __read_mostly;
37 
gfs2_assert_i(struct gfs2_sbd * sdp)38 void gfs2_assert_i(struct gfs2_sbd *sdp)
39 {
40 	fs_emerg(sdp, "fatal assertion failed\n");
41 }
42 
43 /**
44  * check_journal_clean - Make sure a journal is clean for a spectator mount
45  * @sdp: The GFS2 superblock
46  * @jd: The journal descriptor
47  * @verbose: Show more prints in the log
48  *
49  * Returns: 0 if the journal is clean or locked, else an error
50  */
check_journal_clean(struct gfs2_sbd * sdp,struct gfs2_jdesc * jd,bool verbose)51 int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
52 			bool verbose)
53 {
54 	int error;
55 	struct gfs2_holder j_gh;
56 	struct gfs2_log_header_host head;
57 	struct gfs2_inode *ip;
58 
59 	ip = GFS2_I(jd->jd_inode);
60 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_NOEXP |
61 				   GL_EXACT | GL_NOCACHE, &j_gh);
62 	if (error) {
63 		if (verbose)
64 			fs_err(sdp, "Error %d locking journal for spectator "
65 			       "mount.\n", error);
66 		return -EPERM;
67 	}
68 	error = gfs2_jdesc_check(jd);
69 	if (error) {
70 		if (verbose)
71 			fs_err(sdp, "Error checking journal for spectator "
72 			       "mount.\n");
73 		goto out_unlock;
74 	}
75 	error = gfs2_find_jhead(jd, &head, false);
76 	if (error) {
77 		if (verbose)
78 			fs_err(sdp, "Error parsing journal for spectator "
79 			       "mount.\n");
80 		goto out_unlock;
81 	}
82 	if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
83 		error = -EPERM;
84 		if (verbose)
85 			fs_err(sdp, "jid=%u: Journal is dirty, so the first "
86 			       "mounter must not be a spectator.\n",
87 			       jd->jd_jid);
88 	}
89 
90 out_unlock:
91 	gfs2_glock_dq_uninit(&j_gh);
92 	return error;
93 }
94 
95 /**
96  * gfs2_freeze_lock - hold the freeze glock
97  * @sdp: the superblock
98  * @freeze_gh: pointer to the requested holder
99  * @caller_flags: any additional flags needed by the caller
100  */
gfs2_freeze_lock(struct gfs2_sbd * sdp,struct gfs2_holder * freeze_gh,int caller_flags)101 int gfs2_freeze_lock(struct gfs2_sbd *sdp, struct gfs2_holder *freeze_gh,
102 		     int caller_flags)
103 {
104 	int flags = LM_FLAG_NOEXP | GL_EXACT | caller_flags;
105 	int error;
106 
107 	error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, flags,
108 				   freeze_gh);
109 	if (error && error != GLR_TRYFAILED)
110 		fs_err(sdp, "can't lock the freeze lock: %d\n", error);
111 	return error;
112 }
113 
gfs2_freeze_unlock(struct gfs2_holder * freeze_gh)114 void gfs2_freeze_unlock(struct gfs2_holder *freeze_gh)
115 {
116 	if (gfs2_holder_initialized(freeze_gh))
117 		gfs2_glock_dq_uninit(freeze_gh);
118 }
119 
signal_our_withdraw(struct gfs2_sbd * sdp)120 static void signal_our_withdraw(struct gfs2_sbd *sdp)
121 {
122 	struct gfs2_glock *live_gl = sdp->sd_live_gh.gh_gl;
123 	struct inode *inode;
124 	struct gfs2_inode *ip;
125 	struct gfs2_glock *i_gl;
126 	u64 no_formal_ino;
127 	int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
128 	int ret = 0;
129 	int tries;
130 
131 	if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) || !sdp->sd_jdesc)
132 		return;
133 
134 	gfs2_ail_drain(sdp); /* frees all transactions */
135 	inode = sdp->sd_jdesc->jd_inode;
136 	ip = GFS2_I(inode);
137 	i_gl = ip->i_gl;
138 	no_formal_ino = ip->i_no_formal_ino;
139 
140 	/* Prevent any glock dq until withdraw recovery is complete */
141 	set_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
142 	/*
143 	 * Don't tell dlm we're bailing until we have no more buffers in the
144 	 * wind. If journal had an IO error, the log code should just purge
145 	 * the outstanding buffers rather than submitting new IO. Making the
146 	 * file system read-only will flush the journal, etc.
147 	 *
148 	 * During a normal unmount, gfs2_make_fs_ro calls gfs2_log_shutdown
149 	 * which clears SDF_JOURNAL_LIVE. In a withdraw, we must not write
150 	 * any UNMOUNT log header, so we can't call gfs2_log_shutdown, and
151 	 * therefore we need to clear SDF_JOURNAL_LIVE manually.
152 	 */
153 	clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
154 	if (!sb_rdonly(sdp->sd_vfs)) {
155 		struct gfs2_holder freeze_gh;
156 
157 		gfs2_holder_mark_uninitialized(&freeze_gh);
158 		if (sdp->sd_freeze_gl &&
159 		    !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) {
160 			ret = gfs2_freeze_lock(sdp, &freeze_gh,
161 				       log_write_allowed ? 0 : LM_FLAG_TRY);
162 			if (ret == GLR_TRYFAILED)
163 				ret = 0;
164 		}
165 		if (!ret)
166 			gfs2_make_fs_ro(sdp);
167 		/*
168 		 * Dequeue any pending non-system glock holders that can no
169 		 * longer be granted because the file system is withdrawn.
170 		 */
171 		gfs2_gl_dq_holders(sdp);
172 		gfs2_freeze_unlock(&freeze_gh);
173 	}
174 
175 	if (sdp->sd_lockstruct.ls_ops->lm_lock == NULL) { /* lock_nolock */
176 		if (!ret)
177 			ret = -EIO;
178 		clear_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
179 		goto skip_recovery;
180 	}
181 	/*
182 	 * Drop the glock for our journal so another node can recover it.
183 	 */
184 	if (gfs2_holder_initialized(&sdp->sd_journal_gh)) {
185 		gfs2_glock_dq_wait(&sdp->sd_journal_gh);
186 		gfs2_holder_uninit(&sdp->sd_journal_gh);
187 	}
188 	sdp->sd_jinode_gh.gh_flags |= GL_NOCACHE;
189 	gfs2_glock_dq(&sdp->sd_jinode_gh);
190 	if (test_bit(SDF_FS_FROZEN, &sdp->sd_flags)) {
191 		/* Make sure gfs2_unfreeze works if partially-frozen */
192 		flush_work(&sdp->sd_freeze_work);
193 		atomic_set(&sdp->sd_freeze_state, SFS_FROZEN);
194 		thaw_super(sdp->sd_vfs);
195 	} else {
196 		wait_on_bit(&i_gl->gl_flags, GLF_DEMOTE,
197 			    TASK_UNINTERRUPTIBLE);
198 	}
199 
200 	/*
201 	 * holder_uninit to force glock_put, to force dlm to let go
202 	 */
203 	gfs2_holder_uninit(&sdp->sd_jinode_gh);
204 
205 	/*
206 	 * Note: We need to be careful here:
207 	 * Our iput of jd_inode will evict it. The evict will dequeue its
208 	 * glock, but the glock dq will wait for the withdraw unless we have
209 	 * exception code in glock_dq.
210 	 */
211 	iput(inode);
212 	sdp->sd_jdesc->jd_inode = NULL;
213 	/*
214 	 * Wait until the journal inode's glock is freed. This allows try locks
215 	 * on other nodes to be successful, otherwise we remain the owner of
216 	 * the glock as far as dlm is concerned.
217 	 */
218 	if (i_gl->gl_ops->go_free) {
219 		set_bit(GLF_FREEING, &i_gl->gl_flags);
220 		wait_on_bit(&i_gl->gl_flags, GLF_FREEING, TASK_UNINTERRUPTIBLE);
221 	}
222 
223 	/*
224 	 * Dequeue the "live" glock, but keep a reference so it's never freed.
225 	 */
226 	gfs2_glock_hold(live_gl);
227 	gfs2_glock_dq_wait(&sdp->sd_live_gh);
228 	/*
229 	 * We enqueue the "live" glock in EX so that all other nodes
230 	 * get a demote request and act on it. We don't really want the
231 	 * lock in EX, so we send a "try" lock with 1CB to produce a callback.
232 	 */
233 	fs_warn(sdp, "Requesting recovery of jid %d.\n",
234 		sdp->sd_lockstruct.ls_jid);
235 	gfs2_holder_reinit(LM_ST_EXCLUSIVE,
236 			   LM_FLAG_TRY_1CB | LM_FLAG_NOEXP | GL_NOPID,
237 			   &sdp->sd_live_gh);
238 	msleep(GL_GLOCK_MAX_HOLD);
239 	/*
240 	 * This will likely fail in a cluster, but succeed standalone:
241 	 */
242 	ret = gfs2_glock_nq(&sdp->sd_live_gh);
243 
244 	/*
245 	 * If we actually got the "live" lock in EX mode, there are no other
246 	 * nodes available to replay our journal. So we try to replay it
247 	 * ourselves. We hold the "live" glock to prevent other mounters
248 	 * during recovery, then just dequeue it and reacquire it in our
249 	 * normal SH mode. Just in case the problem that caused us to
250 	 * withdraw prevents us from recovering our journal (e.g. io errors
251 	 * and such) we still check if the journal is clean before proceeding
252 	 * but we may wait forever until another mounter does the recovery.
253 	 */
254 	if (ret == 0) {
255 		fs_warn(sdp, "No other mounters found. Trying to recover our "
256 			"own journal jid %d.\n", sdp->sd_lockstruct.ls_jid);
257 		if (gfs2_recover_journal(sdp->sd_jdesc, 1))
258 			fs_warn(sdp, "Unable to recover our journal jid %d.\n",
259 				sdp->sd_lockstruct.ls_jid);
260 		gfs2_glock_dq_wait(&sdp->sd_live_gh);
261 		gfs2_holder_reinit(LM_ST_SHARED,
262 				   LM_FLAG_NOEXP | GL_EXACT | GL_NOPID,
263 				   &sdp->sd_live_gh);
264 		gfs2_glock_nq(&sdp->sd_live_gh);
265 	}
266 
267 	gfs2_glock_queue_put(live_gl); /* drop extra reference we acquired */
268 	clear_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
269 
270 	/*
271 	 * At this point our journal is evicted, so we need to get a new inode
272 	 * for it. Once done, we need to call gfs2_find_jhead which
273 	 * calls gfs2_map_journal_extents to map it for us again.
274 	 *
275 	 * Note that we don't really want it to look up a FREE block. The
276 	 * GFS2_BLKST_FREE simply overrides a block check in gfs2_inode_lookup
277 	 * which would otherwise fail because it requires grabbing an rgrp
278 	 * glock, which would fail with -EIO because we're withdrawing.
279 	 */
280 	inode = gfs2_inode_lookup(sdp->sd_vfs, DT_UNKNOWN,
281 				  sdp->sd_jdesc->jd_no_addr, no_formal_ino,
282 				  GFS2_BLKST_FREE);
283 	if (IS_ERR(inode)) {
284 		fs_warn(sdp, "Reprocessing of jid %d failed with %ld.\n",
285 			sdp->sd_lockstruct.ls_jid, PTR_ERR(inode));
286 		goto skip_recovery;
287 	}
288 	sdp->sd_jdesc->jd_inode = inode;
289 	d_mark_dontcache(inode);
290 
291 	/*
292 	 * Now wait until recovery is complete.
293 	 */
294 	for (tries = 0; tries < 10; tries++) {
295 		ret = check_journal_clean(sdp, sdp->sd_jdesc, false);
296 		if (!ret)
297 			break;
298 		msleep(HZ);
299 		fs_warn(sdp, "Waiting for journal recovery jid %d.\n",
300 			sdp->sd_lockstruct.ls_jid);
301 	}
302 skip_recovery:
303 	if (!ret)
304 		fs_warn(sdp, "Journal recovery complete for jid %d.\n",
305 			sdp->sd_lockstruct.ls_jid);
306 	else
307 		fs_warn(sdp, "Journal recovery skipped for jid %d until next "
308 			"mount.\n", sdp->sd_lockstruct.ls_jid);
309 	fs_warn(sdp, "Glock dequeues delayed: %lu\n", sdp->sd_glock_dqs_held);
310 	sdp->sd_glock_dqs_held = 0;
311 	wake_up_bit(&sdp->sd_flags, SDF_WITHDRAW_RECOVERY);
312 }
313 
gfs2_lm(struct gfs2_sbd * sdp,const char * fmt,...)314 void gfs2_lm(struct gfs2_sbd *sdp, const char *fmt, ...)
315 {
316 	struct va_format vaf;
317 	va_list args;
318 
319 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW &&
320 	    test_bit(SDF_WITHDRAWN, &sdp->sd_flags))
321 		return;
322 
323 	va_start(args, fmt);
324 	vaf.fmt = fmt;
325 	vaf.va = &args;
326 	fs_err(sdp, "%pV", &vaf);
327 	va_end(args);
328 }
329 
gfs2_withdraw(struct gfs2_sbd * sdp)330 int gfs2_withdraw(struct gfs2_sbd *sdp)
331 {
332 	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
333 	const struct lm_lockops *lm = ls->ls_ops;
334 
335 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW &&
336 	    test_and_set_bit(SDF_WITHDRAWN, &sdp->sd_flags)) {
337 		if (!test_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags))
338 			return -1;
339 
340 		wait_on_bit(&sdp->sd_flags, SDF_WITHDRAW_IN_PROG,
341 			    TASK_UNINTERRUPTIBLE);
342 		return -1;
343 	}
344 
345 	set_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags);
346 
347 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW) {
348 		fs_err(sdp, "about to withdraw this file system\n");
349 		BUG_ON(sdp->sd_args.ar_debug);
350 
351 		signal_our_withdraw(sdp);
352 
353 		kobject_uevent(&sdp->sd_kobj, KOBJ_OFFLINE);
354 
355 		if (!strcmp(sdp->sd_lockstruct.ls_ops->lm_proto_name, "lock_dlm"))
356 			wait_for_completion(&sdp->sd_wdack);
357 
358 		if (lm->lm_unmount) {
359 			fs_err(sdp, "telling LM to unmount\n");
360 			lm->lm_unmount(sdp);
361 		}
362 		set_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags);
363 		fs_err(sdp, "File system withdrawn\n");
364 		dump_stack();
365 		clear_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags);
366 		smp_mb__after_atomic();
367 		wake_up_bit(&sdp->sd_flags, SDF_WITHDRAW_IN_PROG);
368 	}
369 
370 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
371 		panic("GFS2: fsid=%s: panic requested\n", sdp->sd_fsname);
372 
373 	return -1;
374 }
375 
376 /*
377  * gfs2_assert_withdraw_i - Cause the machine to withdraw if @assertion is false
378  */
379 
gfs2_assert_withdraw_i(struct gfs2_sbd * sdp,char * assertion,const char * function,char * file,unsigned int line,bool delayed)380 void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
381 			    const char *function, char *file, unsigned int line,
382 			    bool delayed)
383 {
384 	if (gfs2_withdrawn(sdp))
385 		return;
386 
387 	fs_err(sdp,
388 	       "fatal: assertion \"%s\" failed\n"
389 	       "   function = %s, file = %s, line = %u\n",
390 	       assertion, function, file, line);
391 
392 	/*
393 	 * If errors=panic was specified on mount, it won't help to delay the
394 	 * withdraw.
395 	 */
396 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
397 		delayed = false;
398 
399 	if (delayed)
400 		gfs2_withdraw_delayed(sdp);
401 	else
402 		gfs2_withdraw(sdp);
403 	dump_stack();
404 }
405 
406 /*
407  * gfs2_assert_warn_i - Print a message to the console if @assertion is false
408  */
409 
gfs2_assert_warn_i(struct gfs2_sbd * sdp,char * assertion,const char * function,char * file,unsigned int line)410 void gfs2_assert_warn_i(struct gfs2_sbd *sdp, char *assertion,
411 			const char *function, char *file, unsigned int line)
412 {
413 	if (time_before(jiffies,
414 			sdp->sd_last_warning +
415 			gfs2_tune_get(sdp, gt_complain_secs) * HZ))
416 		return;
417 
418 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW)
419 		fs_warn(sdp, "warning: assertion \"%s\" failed at function = %s, file = %s, line = %u\n",
420 			assertion, function, file, line);
421 
422 	if (sdp->sd_args.ar_debug)
423 		BUG();
424 	else
425 		dump_stack();
426 
427 	if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
428 		panic("GFS2: fsid=%s: warning: assertion \"%s\" failed\n"
429 		      "GFS2: fsid=%s:   function = %s, file = %s, line = %u\n",
430 		      sdp->sd_fsname, assertion,
431 		      sdp->sd_fsname, function, file, line);
432 
433 	sdp->sd_last_warning = jiffies;
434 }
435 
436 /*
437  * gfs2_consist_i - Flag a filesystem consistency error and withdraw
438  */
439 
gfs2_consist_i(struct gfs2_sbd * sdp,const char * function,char * file,unsigned int line)440 void gfs2_consist_i(struct gfs2_sbd *sdp, const char *function,
441 		    char *file, unsigned int line)
442 {
443 	gfs2_lm(sdp,
444 		"fatal: filesystem consistency error - function = %s, file = %s, line = %u\n",
445 		function, file, line);
446 	gfs2_withdraw(sdp);
447 }
448 
449 /*
450  * gfs2_consist_inode_i - Flag an inode consistency error and withdraw
451  */
452 
gfs2_consist_inode_i(struct gfs2_inode * ip,const char * function,char * file,unsigned int line)453 void gfs2_consist_inode_i(struct gfs2_inode *ip,
454 			  const char *function, char *file, unsigned int line)
455 {
456 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
457 
458 	gfs2_lm(sdp,
459 		"fatal: filesystem consistency error\n"
460 		"  inode = %llu %llu\n"
461 		"  function = %s, file = %s, line = %u\n",
462 		(unsigned long long)ip->i_no_formal_ino,
463 		(unsigned long long)ip->i_no_addr,
464 		function, file, line);
465 	gfs2_dump_glock(NULL, ip->i_gl, 1);
466 	gfs2_withdraw(sdp);
467 }
468 
469 /*
470  * gfs2_consist_rgrpd_i - Flag a RG consistency error and withdraw
471  */
472 
gfs2_consist_rgrpd_i(struct gfs2_rgrpd * rgd,const char * function,char * file,unsigned int line)473 void gfs2_consist_rgrpd_i(struct gfs2_rgrpd *rgd,
474 			  const char *function, char *file, unsigned int line)
475 {
476 	struct gfs2_sbd *sdp = rgd->rd_sbd;
477 	char fs_id_buf[sizeof(sdp->sd_fsname) + 7];
478 
479 	sprintf(fs_id_buf, "fsid=%s: ", sdp->sd_fsname);
480 	gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
481 	gfs2_lm(sdp,
482 		"fatal: filesystem consistency error\n"
483 		"  RG = %llu\n"
484 		"  function = %s, file = %s, line = %u\n",
485 		(unsigned long long)rgd->rd_addr,
486 		function, file, line);
487 	gfs2_dump_glock(NULL, rgd->rd_gl, 1);
488 	gfs2_withdraw(sdp);
489 }
490 
491 /*
492  * gfs2_meta_check_ii - Flag a magic number consistency error and withdraw
493  * Returns: -1 if this call withdrew the machine,
494  *          -2 if it was already withdrawn
495  */
496 
gfs2_meta_check_ii(struct gfs2_sbd * sdp,struct buffer_head * bh,const char * type,const char * function,char * file,unsigned int line)497 int gfs2_meta_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
498 		       const char *type, const char *function, char *file,
499 		       unsigned int line)
500 {
501 	int me;
502 
503 	gfs2_lm(sdp,
504 		"fatal: invalid metadata block\n"
505 		"  bh = %llu (%s)\n"
506 		"  function = %s, file = %s, line = %u\n",
507 		(unsigned long long)bh->b_blocknr, type,
508 		function, file, line);
509 	me = gfs2_withdraw(sdp);
510 	return (me) ? -1 : -2;
511 }
512 
513 /*
514  * gfs2_metatype_check_ii - Flag a metadata type consistency error and withdraw
515  * Returns: -1 if this call withdrew the machine,
516  *          -2 if it was already withdrawn
517  */
518 
gfs2_metatype_check_ii(struct gfs2_sbd * sdp,struct buffer_head * bh,u16 type,u16 t,const char * function,char * file,unsigned int line)519 int gfs2_metatype_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
520 			   u16 type, u16 t, const char *function,
521 			   char *file, unsigned int line)
522 {
523 	int me;
524 
525 	gfs2_lm(sdp,
526 		"fatal: invalid metadata block\n"
527 		"  bh = %llu (type: exp=%u, found=%u)\n"
528 		"  function = %s, file = %s, line = %u\n",
529 		(unsigned long long)bh->b_blocknr, type, t,
530 		function, file, line);
531 	me = gfs2_withdraw(sdp);
532 	return (me) ? -1 : -2;
533 }
534 
535 /*
536  * gfs2_io_error_i - Flag an I/O error and withdraw
537  * Returns: -1 if this call withdrew the machine,
538  *          0 if it was already withdrawn
539  */
540 
gfs2_io_error_i(struct gfs2_sbd * sdp,const char * function,char * file,unsigned int line)541 int gfs2_io_error_i(struct gfs2_sbd *sdp, const char *function, char *file,
542 		    unsigned int line)
543 {
544 	gfs2_lm(sdp,
545 		"fatal: I/O error\n"
546 		"  function = %s, file = %s, line = %u\n",
547 		function, file, line);
548 	return gfs2_withdraw(sdp);
549 }
550 
551 /*
552  * gfs2_io_error_bh_i - Flag a buffer I/O error
553  * @withdraw: withdraw the filesystem
554  */
555 
gfs2_io_error_bh_i(struct gfs2_sbd * sdp,struct buffer_head * bh,const char * function,char * file,unsigned int line,bool withdraw)556 void gfs2_io_error_bh_i(struct gfs2_sbd *sdp, struct buffer_head *bh,
557 			const char *function, char *file, unsigned int line,
558 			bool withdraw)
559 {
560 	if (gfs2_withdrawn(sdp))
561 		return;
562 
563 	fs_err(sdp, "fatal: I/O error\n"
564 	       "  block = %llu\n"
565 	       "  function = %s, file = %s, line = %u\n",
566 	       (unsigned long long)bh->b_blocknr, function, file, line);
567 	if (withdraw)
568 		gfs2_withdraw(sdp);
569 }
570 
571