Linux Audio

Check our new training course

Loading...
v4.17
 
  1/*
  2 *   Copyright (C) International Business Machines Corp., 2000-2004
  3 *
  4 *   This program is free software;  you can redistribute it and/or modify
  5 *   it under the terms of the GNU General Public License as published by
  6 *   the Free Software Foundation; either version 2 of the License, or
  7 *   (at your option) any later version.
  8 *
  9 *   This program is distributed in the hope that it will be useful,
 10 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 11 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 12 *   the GNU General Public License for more details.
 13 *
 14 *   You should have received a copy of the GNU General Public License
 15 *   along with this program;  if not, write to the Free Software
 16 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 17 */
 18
 19/*
 20 *	jfs_umount.c
 21 *
 22 * note: file system in transition to aggregate/fileset:
 23 * (ref. jfs_mount.c)
 24 *
 25 * file system unmount is interpreted as mount of the single/only
 26 * fileset in the aggregate and, if unmount of the last fileset,
 27 * as unmount of the aggerate;
 28 */
 29
 30#include <linux/fs.h>
 31#include "jfs_incore.h"
 32#include "jfs_filsys.h"
 33#include "jfs_superblock.h"
 34#include "jfs_dmap.h"
 35#include "jfs_imap.h"
 36#include "jfs_metapage.h"
 37#include "jfs_debug.h"
 38
 39/*
 40 * NAME:	jfs_umount(vfsp, flags, crp)
 41 *
 42 * FUNCTION:	vfs_umount()
 43 *
 44 * PARAMETERS:	vfsp	- virtual file system pointer
 45 *		flags	- unmount for shutdown
 46 *		crp	- credential
 47 *
 48 * RETURN :	EBUSY	- device has open files
 49 */
 50int jfs_umount(struct super_block *sb)
 51{
 52	struct jfs_sb_info *sbi = JFS_SBI(sb);
 53	struct inode *ipbmap = sbi->ipbmap;
 54	struct inode *ipimap = sbi->ipimap;
 55	struct inode *ipaimap = sbi->ipaimap;
 56	struct inode *ipaimap2 = sbi->ipaimap2;
 57	struct jfs_log *log;
 58	int rc = 0;
 59
 60	jfs_info("UnMount JFS: sb:0x%p", sb);
 61
 62	/*
 63	 *	update superblock and close log
 64	 *
 65	 * if mounted read-write and log based recovery was enabled
 66	 */
 67	if ((log = sbi->log))
 68		/*
 69		 * Wait for outstanding transactions to be written to log:
 70		 */
 71		jfs_flush_journal(log, 2);
 72
 73	/*
 74	 * close fileset inode allocation map (aka fileset inode)
 75	 */
 76	diUnmount(ipimap, 0);
 77
 78	diFreeSpecial(ipimap);
 79	sbi->ipimap = NULL;
 80
 81	/*
 82	 * close secondary aggregate inode allocation map
 83	 */
 84	ipaimap2 = sbi->ipaimap2;
 85	if (ipaimap2) {
 86		diUnmount(ipaimap2, 0);
 87		diFreeSpecial(ipaimap2);
 88		sbi->ipaimap2 = NULL;
 89	}
 90
 91	/*
 92	 * close aggregate inode allocation map
 93	 */
 94	ipaimap = sbi->ipaimap;
 95	diUnmount(ipaimap, 0);
 96	diFreeSpecial(ipaimap);
 97	sbi->ipaimap = NULL;
 98
 99	/*
100	 * close aggregate block allocation map
101	 */
102	dbUnmount(ipbmap, 0);
103
104	diFreeSpecial(ipbmap);
105	sbi->ipimap = NULL;
106
107	/*
108	 * Make sure all metadata makes it to disk before we mark
109	 * the superblock as clean
110	 */
111	filemap_write_and_wait(sbi->direct_inode->i_mapping);
112
113	/*
114	 * ensure all file system file pages are propagated to their
115	 * home blocks on disk (and their in-memory buffer pages are
116	 * invalidated) BEFORE updating file system superblock state
117	 * (to signify file system is unmounted cleanly, and thus in
118	 * consistent state) and log superblock active file system
119	 * list (to signify skip logredo()).
120	 */
121	if (log) {		/* log = NULL if read-only mount */
122		updateSuper(sb, FM_CLEAN);
123
124		/*
125		 * close log:
126		 *
127		 * remove file system from log active file system list.
128		 */
129		rc = lmLogClose(sb);
130	}
131	jfs_info("UnMount JFS Complete: rc = %d", rc);
132	return rc;
133}
134
135
136int jfs_umount_rw(struct super_block *sb)
137{
138	struct jfs_sb_info *sbi = JFS_SBI(sb);
139	struct jfs_log *log = sbi->log;
140
141	if (!log)
142		return 0;
143
144	/*
145	 * close log:
146	 *
147	 * remove file system from log active file system list.
148	 */
149	jfs_flush_journal(log, 2);
150
151	/*
152	 * Make sure all metadata makes it to disk
153	 */
154	dbSync(sbi->ipbmap);
155	diSync(sbi->ipimap);
156
157	/*
158	 * Note that we have to do this even if sync_blockdev() will
159	 * do exactly the same a few instructions later:  We can't
160	 * mark the superblock clean before everything is flushed to
161	 * disk.
162	 */
163	filemap_write_and_wait(sbi->direct_inode->i_mapping);
164
165	updateSuper(sb, FM_CLEAN);
166
167	return lmLogClose(sb);
168}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *   Copyright (C) International Business Machines Corp., 2000-2004
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  4 */
  5
  6/*
  7 *	jfs_umount.c
  8 *
  9 * note: file system in transition to aggregate/fileset:
 10 * (ref. jfs_mount.c)
 11 *
 12 * file system unmount is interpreted as mount of the single/only
 13 * fileset in the aggregate and, if unmount of the last fileset,
 14 * as unmount of the aggerate;
 15 */
 16
 17#include <linux/fs.h>
 18#include "jfs_incore.h"
 19#include "jfs_filsys.h"
 20#include "jfs_superblock.h"
 21#include "jfs_dmap.h"
 22#include "jfs_imap.h"
 23#include "jfs_metapage.h"
 24#include "jfs_debug.h"
 25
 26/*
 27 * NAME:	jfs_umount(vfsp, flags, crp)
 28 *
 29 * FUNCTION:	vfs_umount()
 30 *
 31 * PARAMETERS:	vfsp	- virtual file system pointer
 32 *		flags	- unmount for shutdown
 33 *		crp	- credential
 34 *
 35 * RETURN :	EBUSY	- device has open files
 36 */
 37int jfs_umount(struct super_block *sb)
 38{
 39	struct jfs_sb_info *sbi = JFS_SBI(sb);
 40	struct inode *ipbmap = sbi->ipbmap;
 41	struct inode *ipimap = sbi->ipimap;
 42	struct inode *ipaimap = sbi->ipaimap;
 43	struct inode *ipaimap2 = sbi->ipaimap2;
 44	struct jfs_log *log;
 45	int rc = 0;
 46
 47	jfs_info("UnMount JFS: sb:0x%p", sb);
 48
 49	/*
 50	 *	update superblock and close log
 51	 *
 52	 * if mounted read-write and log based recovery was enabled
 53	 */
 54	if ((log = sbi->log))
 55		/*
 56		 * Wait for outstanding transactions to be written to log:
 57		 */
 58		jfs_flush_journal(log, 2);
 59
 60	/*
 61	 * close fileset inode allocation map (aka fileset inode)
 62	 */
 63	diUnmount(ipimap, 0);
 64
 65	diFreeSpecial(ipimap);
 66	sbi->ipimap = NULL;
 67
 68	/*
 69	 * close secondary aggregate inode allocation map
 70	 */
 
 71	if (ipaimap2) {
 72		diUnmount(ipaimap2, 0);
 73		diFreeSpecial(ipaimap2);
 74		sbi->ipaimap2 = NULL;
 75	}
 76
 77	/*
 78	 * close aggregate inode allocation map
 79	 */
 
 80	diUnmount(ipaimap, 0);
 81	diFreeSpecial(ipaimap);
 82	sbi->ipaimap = NULL;
 83
 84	/*
 85	 * close aggregate block allocation map
 86	 */
 87	dbUnmount(ipbmap, 0);
 88
 89	diFreeSpecial(ipbmap);
 90	sbi->ipbmap = NULL;
 91
 92	/*
 93	 * Make sure all metadata makes it to disk before we mark
 94	 * the superblock as clean
 95	 */
 96	filemap_write_and_wait(sbi->direct_inode->i_mapping);
 97
 98	/*
 99	 * ensure all file system file pages are propagated to their
100	 * home blocks on disk (and their in-memory buffer pages are
101	 * invalidated) BEFORE updating file system superblock state
102	 * (to signify file system is unmounted cleanly, and thus in
103	 * consistent state) and log superblock active file system
104	 * list (to signify skip logredo()).
105	 */
106	if (log) {		/* log = NULL if read-only mount */
107		updateSuper(sb, FM_CLEAN);
108
109		/*
110		 * close log:
111		 *
112		 * remove file system from log active file system list.
113		 */
114		rc = lmLogClose(sb);
115	}
116	jfs_info("UnMount JFS Complete: rc = %d", rc);
117	return rc;
118}
119
120
121int jfs_umount_rw(struct super_block *sb)
122{
123	struct jfs_sb_info *sbi = JFS_SBI(sb);
124	struct jfs_log *log = sbi->log;
125
126	if (!log)
127		return 0;
128
129	/*
130	 * close log:
131	 *
132	 * remove file system from log active file system list.
133	 */
134	jfs_flush_journal(log, 2);
135
136	/*
137	 * Make sure all metadata makes it to disk
138	 */
139	dbSync(sbi->ipbmap);
140	diSync(sbi->ipimap);
141
142	/*
143	 * Note that we have to do this even if sync_blockdev() will
144	 * do exactly the same a few instructions later:  We can't
145	 * mark the superblock clean before everything is flushed to
146	 * disk.
147	 */
148	filemap_write_and_wait(sbi->direct_inode->i_mapping);
149
150	updateSuper(sb, FM_CLEAN);
151
152	return lmLogClose(sb);
153}