aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--fs/xfs/linux-2.6/xfs_super.c499
-rw-r--r--fs/xfs/quota/xfs_qm.c1
-rw-r--r--fs/xfs/quota/xfs_qm_bhv.c1
-rw-r--r--fs/xfs/xfs_clnt.h105
-rw-r--r--fs/xfs/xfs_dmops.c5
-rw-r--r--fs/xfs/xfs_mount.h4
-rw-r--r--fs/xfs/xfs_qmops.c5
-rw-r--r--fs/xfs/xfs_vfsops.c1
8 files changed, 195 insertions, 426 deletions
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 655508ce2b73..5638a99fb741 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -18,7 +18,6 @@
18#include "xfs.h" 18#include "xfs.h"
19#include "xfs_bit.h" 19#include "xfs_bit.h"
20#include "xfs_log.h" 20#include "xfs_log.h"
21#include "xfs_clnt.h"
22#include "xfs_inum.h" 21#include "xfs_inum.h"
23#include "xfs_trans.h" 22#include "xfs_trans.h"
24#include "xfs_sb.h" 23#include "xfs_sb.h"
@@ -75,32 +74,6 @@ static struct super_operations xfs_super_operations;
75static kmem_zone_t *xfs_ioend_zone; 74static kmem_zone_t *xfs_ioend_zone;
76mempool_t *xfs_ioend_pool; 75mempool_t *xfs_ioend_pool;
77 76
78STATIC struct xfs_mount_args *
79xfs_args_allocate(
80 struct super_block *sb,
81 int silent)
82{
83 struct xfs_mount_args *args;
84
85 args = kzalloc(sizeof(struct xfs_mount_args), GFP_KERNEL);
86 if (!args)
87 return NULL;
88
89 args->logbufs = args->logbufsize = -1;
90 strncpy(args->fsname, sb->s_id, MAXNAMELEN);
91
92 /* Copy the already-parsed mount(2) flags we're interested in */
93 if (sb->s_flags & MS_DIRSYNC)
94 args->flags |= XFSMNT_DIRSYNC;
95 if (sb->s_flags & MS_SYNCHRONOUS)
96 args->flags |= XFSMNT_WSYNC;
97 if (silent)
98 args->flags |= XFSMNT_QUIET;
99 args->flags |= XFSMNT_32BITINODES;
100
101 return args;
102}
103
104#define MNTOPT_LOGBUFS "logbufs" /* number of XFS log buffers */ 77#define MNTOPT_LOGBUFS "logbufs" /* number of XFS log buffers */
105#define MNTOPT_LOGBSIZE "logbsize" /* size of XFS log buffers */ 78#define MNTOPT_LOGBSIZE "logbsize" /* size of XFS log buffers */
106#define MNTOPT_LOGDEV "logdev" /* log device */ 79#define MNTOPT_LOGDEV "logdev" /* log device */
@@ -189,26 +162,54 @@ suffix_strtoul(char *s, char **endp, unsigned int base)
189 return simple_strtoul((const char *)s, endp, base) << shift_left_factor; 162 return simple_strtoul((const char *)s, endp, base) << shift_left_factor;
190} 163}
191 164
165/*
166 * This function fills in xfs_mount_t fields based on mount args.
167 * Note: the superblock has _not_ yet been read in.
168 *
169 * Note that this function leaks the various device name allocations on
170 * failure. The caller takes care of them.
171 */
192STATIC int 172STATIC int
193xfs_parseargs( 173xfs_parseargs(
194 struct xfs_mount *mp, 174 struct xfs_mount *mp,
195 char *options, 175 char *options,
196 struct xfs_mount_args *args, 176 char **mtpt)
197 int update)
198{ 177{
178 struct super_block *sb = mp->m_super;
199 char *this_char, *value, *eov; 179 char *this_char, *value, *eov;
200 int dsunit, dswidth, vol_dsunit, vol_dswidth; 180 int dsunit = 0;
201 int iosize; 181 int dswidth = 0;
182 int iosize = 0;
202 int dmapi_implies_ikeep = 1; 183 int dmapi_implies_ikeep = 1;
184 uchar_t iosizelog = 0;
185
186 /*
187 * Copy binary VFS mount flags we are interested in.
188 */
189 if (sb->s_flags & MS_RDONLY)
190 mp->m_flags |= XFS_MOUNT_RDONLY;
191 if (sb->s_flags & MS_DIRSYNC)
192 mp->m_flags |= XFS_MOUNT_DIRSYNC;
193 if (sb->s_flags & MS_SYNCHRONOUS)
194 mp->m_flags |= XFS_MOUNT_WSYNC;
195
196 /*
197 * Set some default flags that could be cleared by the mount option
198 * parsing.
199 */
200 mp->m_flags |= XFS_MOUNT_BARRIER;
201 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
202 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
203 203
204 args->flags |= XFSMNT_BARRIER; 204 /*
205 args->flags2 |= XFSMNT2_COMPAT_IOSIZE; 205 * These can be overridden by the mount option parsing.
206 */
207 mp->m_logbufs = -1;
208 mp->m_logbsize = -1;
206 209
207 if (!options) 210 if (!options)
208 goto done; 211 goto done;
209 212
210 iosize = dsunit = dswidth = vol_dsunit = vol_dswidth = 0;
211
212 while ((this_char = strsep(&options, ",")) != NULL) { 213 while ((this_char = strsep(&options, ",")) != NULL) {
213 if (!*this_char) 214 if (!*this_char)
214 continue; 215 continue;
@@ -222,7 +223,7 @@ xfs_parseargs(
222 this_char); 223 this_char);
223 return EINVAL; 224 return EINVAL;
224 } 225 }
225 args->logbufs = simple_strtoul(value, &eov, 10); 226 mp->m_logbufs = simple_strtoul(value, &eov, 10);
226 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) { 227 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
227 if (!value || !*value) { 228 if (!value || !*value) {
228 cmn_err(CE_WARN, 229 cmn_err(CE_WARN,
@@ -230,7 +231,7 @@ xfs_parseargs(
230 this_char); 231 this_char);
231 return EINVAL; 232 return EINVAL;
232 } 233 }
233 args->logbufsize = suffix_strtoul(value, &eov, 10); 234 mp->m_logbsize = suffix_strtoul(value, &eov, 10);
234 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) { 235 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
235 if (!value || !*value) { 236 if (!value || !*value) {
236 cmn_err(CE_WARN, 237 cmn_err(CE_WARN,
@@ -238,7 +239,9 @@ xfs_parseargs(
238 this_char); 239 this_char);
239 return EINVAL; 240 return EINVAL;
240 } 241 }
241 strncpy(args->logname, value, MAXNAMELEN); 242 mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
243 if (!mp->m_logname)
244 return ENOMEM;
242 } else if (!strcmp(this_char, MNTOPT_MTPT)) { 245 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
243 if (!value || !*value) { 246 if (!value || !*value) {
244 cmn_err(CE_WARN, 247 cmn_err(CE_WARN,
@@ -246,7 +249,9 @@ xfs_parseargs(
246 this_char); 249 this_char);
247 return EINVAL; 250 return EINVAL;
248 } 251 }
249 strncpy(args->mtpt, value, MAXNAMELEN); 252 *mtpt = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
253 if (!*mtpt)
254 return ENOMEM;
250 } else if (!strcmp(this_char, MNTOPT_RTDEV)) { 255 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
251 if (!value || !*value) { 256 if (!value || !*value) {
252 cmn_err(CE_WARN, 257 cmn_err(CE_WARN,
@@ -254,7 +259,9 @@ xfs_parseargs(
254 this_char); 259 this_char);
255 return EINVAL; 260 return EINVAL;
256 } 261 }
257 strncpy(args->rtname, value, MAXNAMELEN); 262 mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
263 if (!mp->m_rtname)
264 return ENOMEM;
258 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) { 265 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
259 if (!value || !*value) { 266 if (!value || !*value) {
260 cmn_err(CE_WARN, 267 cmn_err(CE_WARN,
@@ -263,8 +270,7 @@ xfs_parseargs(
263 return EINVAL; 270 return EINVAL;
264 } 271 }
265 iosize = simple_strtoul(value, &eov, 10); 272 iosize = simple_strtoul(value, &eov, 10);
266 args->flags |= XFSMNT_IOSIZE; 273 iosizelog = (uint8_t) iosize;
267 args->iosizelog = (uint8_t) iosize;
268 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) { 274 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
269 if (!value || !*value) { 275 if (!value || !*value) {
270 cmn_err(CE_WARN, 276 cmn_err(CE_WARN,
@@ -273,8 +279,7 @@ xfs_parseargs(
273 return EINVAL; 279 return EINVAL;
274 } 280 }
275 iosize = suffix_strtoul(value, &eov, 10); 281 iosize = suffix_strtoul(value, &eov, 10);
276 args->flags |= XFSMNT_IOSIZE; 282 iosizelog = ffs(iosize) - 1;
277 args->iosizelog = ffs(iosize) - 1;
278 } else if (!strcmp(this_char, MNTOPT_GRPID) || 283 } else if (!strcmp(this_char, MNTOPT_GRPID) ||
279 !strcmp(this_char, MNTOPT_BSDGROUPS)) { 284 !strcmp(this_char, MNTOPT_BSDGROUPS)) {
280 mp->m_flags |= XFS_MOUNT_GRPID; 285 mp->m_flags |= XFS_MOUNT_GRPID;
@@ -282,23 +287,25 @@ xfs_parseargs(
282 !strcmp(this_char, MNTOPT_SYSVGROUPS)) { 287 !strcmp(this_char, MNTOPT_SYSVGROUPS)) {
283 mp->m_flags &= ~XFS_MOUNT_GRPID; 288 mp->m_flags &= ~XFS_MOUNT_GRPID;
284 } else if (!strcmp(this_char, MNTOPT_WSYNC)) { 289 } else if (!strcmp(this_char, MNTOPT_WSYNC)) {
285 args->flags |= XFSMNT_WSYNC; 290 mp->m_flags |= XFS_MOUNT_WSYNC;
286 } else if (!strcmp(this_char, MNTOPT_OSYNCISOSYNC)) { 291 } else if (!strcmp(this_char, MNTOPT_OSYNCISOSYNC)) {
287 args->flags |= XFSMNT_OSYNCISOSYNC; 292 mp->m_flags |= XFS_MOUNT_OSYNCISOSYNC;
288 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) { 293 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
289 args->flags |= XFSMNT_NORECOVERY; 294 mp->m_flags |= XFS_MOUNT_NORECOVERY;
290 } else if (!strcmp(this_char, MNTOPT_INO64)) { 295 } else if (!strcmp(this_char, MNTOPT_INO64)) {
291 args->flags |= XFSMNT_INO64; 296#if XFS_BIG_INUMS
292#if !XFS_BIG_INUMS 297 mp->m_flags |= XFS_MOUNT_INO64;
298 mp->m_inoadd = XFS_INO64_OFFSET;
299#else
293 cmn_err(CE_WARN, 300 cmn_err(CE_WARN,
294 "XFS: %s option not allowed on this system", 301 "XFS: %s option not allowed on this system",
295 this_char); 302 this_char);
296 return EINVAL; 303 return EINVAL;
297#endif 304#endif
298 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) { 305 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
299 args->flags |= XFSMNT_NOALIGN; 306 mp->m_flags |= XFS_MOUNT_NOALIGN;
300 } else if (!strcmp(this_char, MNTOPT_SWALLOC)) { 307 } else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
301 args->flags |= XFSMNT_SWALLOC; 308 mp->m_flags |= XFS_MOUNT_SWALLOC;
302 } else if (!strcmp(this_char, MNTOPT_SUNIT)) { 309 } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
303 if (!value || !*value) { 310 if (!value || !*value) {
304 cmn_err(CE_WARN, 311 cmn_err(CE_WARN,
@@ -316,7 +323,7 @@ xfs_parseargs(
316 } 323 }
317 dswidth = simple_strtoul(value, &eov, 10); 324 dswidth = simple_strtoul(value, &eov, 10);
318 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) { 325 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
319 args->flags &= ~XFSMNT_32BITINODES; 326 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
320#if !XFS_BIG_INUMS 327#if !XFS_BIG_INUMS
321 cmn_err(CE_WARN, 328 cmn_err(CE_WARN,
322 "XFS: %s option not allowed on this system", 329 "XFS: %s option not allowed on this system",
@@ -324,56 +331,60 @@ xfs_parseargs(
324 return EINVAL; 331 return EINVAL;
325#endif 332#endif
326 } else if (!strcmp(this_char, MNTOPT_NOUUID)) { 333 } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
327 args->flags |= XFSMNT_NOUUID; 334 mp->m_flags |= XFS_MOUNT_NOUUID;
328 } else if (!strcmp(this_char, MNTOPT_BARRIER)) { 335 } else if (!strcmp(this_char, MNTOPT_BARRIER)) {
329 args->flags |= XFSMNT_BARRIER; 336 mp->m_flags |= XFS_MOUNT_BARRIER;
330 } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) { 337 } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
331 args->flags &= ~XFSMNT_BARRIER; 338 mp->m_flags &= ~XFS_MOUNT_BARRIER;
332 } else if (!strcmp(this_char, MNTOPT_IKEEP)) { 339 } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
333 args->flags |= XFSMNT_IKEEP; 340 mp->m_flags |= XFS_MOUNT_IKEEP;
334 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) { 341 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
335 dmapi_implies_ikeep = 0; 342 dmapi_implies_ikeep = 0;
336 args->flags &= ~XFSMNT_IKEEP; 343 mp->m_flags &= ~XFS_MOUNT_IKEEP;
337 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) { 344 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
338 args->flags2 &= ~XFSMNT2_COMPAT_IOSIZE; 345 mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
339 } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) { 346 } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
340 args->flags2 |= XFSMNT2_COMPAT_IOSIZE; 347 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
341 } else if (!strcmp(this_char, MNTOPT_ATTR2)) { 348 } else if (!strcmp(this_char, MNTOPT_ATTR2)) {
342 args->flags |= XFSMNT_ATTR2; 349 mp->m_flags |= XFS_MOUNT_ATTR2;
343 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) { 350 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
344 args->flags &= ~XFSMNT_ATTR2; 351 mp->m_flags &= ~XFS_MOUNT_ATTR2;
345 args->flags |= XFSMNT_NOATTR2; 352 mp->m_flags |= XFS_MOUNT_NOATTR2;
346 } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) { 353 } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
347 args->flags2 |= XFSMNT2_FILESTREAMS; 354 mp->m_flags |= XFS_MOUNT_FILESTREAMS;
348 } else if (!strcmp(this_char, MNTOPT_NOQUOTA)) { 355 } else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
349 args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA); 356 mp->m_qflags &= ~(XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
350 args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA); 357 XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
358 XFS_UQUOTA_ENFD | XFS_OQUOTA_ENFD);
351 } else if (!strcmp(this_char, MNTOPT_QUOTA) || 359 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
352 !strcmp(this_char, MNTOPT_UQUOTA) || 360 !strcmp(this_char, MNTOPT_UQUOTA) ||
353 !strcmp(this_char, MNTOPT_USRQUOTA)) { 361 !strcmp(this_char, MNTOPT_USRQUOTA)) {
354 args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF; 362 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
363 XFS_UQUOTA_ENFD);
355 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) || 364 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
356 !strcmp(this_char, MNTOPT_UQUOTANOENF)) { 365 !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
357 args->flags |= XFSMNT_UQUOTA; 366 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
358 args->flags &= ~XFSMNT_UQUOTAENF; 367 mp->m_qflags &= ~XFS_UQUOTA_ENFD;
359 } else if (!strcmp(this_char, MNTOPT_PQUOTA) || 368 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
360 !strcmp(this_char, MNTOPT_PRJQUOTA)) { 369 !strcmp(this_char, MNTOPT_PRJQUOTA)) {
361 args->flags |= XFSMNT_PQUOTA | XFSMNT_PQUOTAENF; 370 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
371 XFS_OQUOTA_ENFD);
362 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) { 372 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
363 args->flags |= XFSMNT_PQUOTA; 373 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
364 args->flags &= ~XFSMNT_PQUOTAENF; 374 mp->m_qflags &= ~XFS_OQUOTA_ENFD;
365 } else if (!strcmp(this_char, MNTOPT_GQUOTA) || 375 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
366 !strcmp(this_char, MNTOPT_GRPQUOTA)) { 376 !strcmp(this_char, MNTOPT_GRPQUOTA)) {
367 args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF; 377 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
378 XFS_OQUOTA_ENFD);
368 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) { 379 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
369 args->flags |= XFSMNT_GQUOTA; 380 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
370 args->flags &= ~XFSMNT_GQUOTAENF; 381 mp->m_qflags &= ~XFS_OQUOTA_ENFD;
371 } else if (!strcmp(this_char, MNTOPT_DMAPI)) { 382 } else if (!strcmp(this_char, MNTOPT_DMAPI)) {
372 args->flags |= XFSMNT_DMAPI; 383 mp->m_flags |= XFS_MOUNT_DMAPI;
373 } else if (!strcmp(this_char, MNTOPT_XDSM)) { 384 } else if (!strcmp(this_char, MNTOPT_XDSM)) {
374 args->flags |= XFSMNT_DMAPI; 385 mp->m_flags |= XFS_MOUNT_DMAPI;
375 } else if (!strcmp(this_char, MNTOPT_DMI)) { 386 } else if (!strcmp(this_char, MNTOPT_DMI)) {
376 args->flags |= XFSMNT_DMAPI; 387 mp->m_flags |= XFS_MOUNT_DMAPI;
377 } else if (!strcmp(this_char, "ihashsize")) { 388 } else if (!strcmp(this_char, "ihashsize")) {
378 cmn_err(CE_WARN, 389 cmn_err(CE_WARN,
379 "XFS: ihashsize no longer used, option is deprecated."); 390 "XFS: ihashsize no longer used, option is deprecated.");
@@ -391,27 +402,29 @@ xfs_parseargs(
391 } 402 }
392 } 403 }
393 404
394 if (args->flags & XFSMNT_NORECOVERY) { 405 /*
395 if ((mp->m_flags & XFS_MOUNT_RDONLY) == 0) { 406 * no recovery flag requires a read-only mount
396 cmn_err(CE_WARN, 407 */
397 "XFS: no-recovery mounts must be read-only."); 408 if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
398 return EINVAL; 409 !(mp->m_flags & XFS_MOUNT_RDONLY)) {
399 } 410 cmn_err(CE_WARN, "XFS: no-recovery mounts must be read-only.");
411 return EINVAL;
400 } 412 }
401 413
402 if ((args->flags & XFSMNT_NOALIGN) && (dsunit || dswidth)) { 414 if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
403 cmn_err(CE_WARN, 415 cmn_err(CE_WARN,
404 "XFS: sunit and swidth options incompatible with the noalign option"); 416 "XFS: sunit and swidth options incompatible with the noalign option");
405 return EINVAL; 417 return EINVAL;
406 } 418 }
407 419
408 if ((args->flags & XFSMNT_GQUOTA) && (args->flags & XFSMNT_PQUOTA)) { 420 if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
421 (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
409 cmn_err(CE_WARN, 422 cmn_err(CE_WARN,
410 "XFS: cannot mount with both project and group quota"); 423 "XFS: cannot mount with both project and group quota");
411 return EINVAL; 424 return EINVAL;
412 } 425 }
413 426
414 if ((args->flags & XFSMNT_DMAPI) && *args->mtpt == '\0') { 427 if ((mp->m_flags & XFS_MOUNT_DMAPI) && (!*mtpt || *mtpt[0] == '\0')) {
415 printk("XFS: %s option needs the mount point option as well\n", 428 printk("XFS: %s option needs the mount point option as well\n",
416 MNTOPT_DMAPI); 429 MNTOPT_DMAPI);
417 return EINVAL; 430 return EINVAL;
@@ -439,27 +452,66 @@ xfs_parseargs(
439 * Note that if "ikeep" or "noikeep" mount options are 452 * Note that if "ikeep" or "noikeep" mount options are
440 * supplied, then they are honored. 453 * supplied, then they are honored.
441 */ 454 */
442 if ((args->flags & XFSMNT_DMAPI) && dmapi_implies_ikeep) 455 if ((mp->m_flags & XFS_MOUNT_DMAPI) && dmapi_implies_ikeep)
443 args->flags |= XFSMNT_IKEEP; 456 mp->m_flags |= XFS_MOUNT_IKEEP;
444 457
445 if ((args->flags & XFSMNT_NOALIGN) != XFSMNT_NOALIGN) { 458done:
459 if (!(mp->m_flags & XFS_MOUNT_NOALIGN)) {
460 /*
461 * At this point the superblock has not been read
462 * in, therefore we do not know the block size.
463 * Before the mount call ends we will convert
464 * these to FSBs.
465 */
446 if (dsunit) { 466 if (dsunit) {
447 args->sunit = dsunit; 467 mp->m_dalign = dsunit;
448 args->flags |= XFSMNT_RETERR; 468 mp->m_flags |= XFS_MOUNT_RETERR;
449 } else {
450 args->sunit = vol_dsunit;
451 } 469 }
452 dswidth ? (args->swidth = dswidth) : 470
453 (args->swidth = vol_dswidth); 471 if (dswidth)
454 } else { 472 mp->m_swidth = dswidth;
455 args->sunit = args->swidth = 0; 473 }
474
475 if (mp->m_logbufs != -1 &&
476 mp->m_logbufs != 0 &&
477 (mp->m_logbufs < XLOG_MIN_ICLOGS ||
478 mp->m_logbufs > XLOG_MAX_ICLOGS)) {
479 cmn_err(CE_WARN,
480 "XFS: invalid logbufs value: %d [not %d-%d]",
481 mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
482 return XFS_ERROR(EINVAL);
483 }
484 if (mp->m_logbsize != -1 &&
485 mp->m_logbsize != 0 &&
486 (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
487 mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
488 !is_power_of_2(mp->m_logbsize))) {
489 cmn_err(CE_WARN,
490 "XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
491 mp->m_logbsize);
492 return XFS_ERROR(EINVAL);
493 }
494
495 mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
496 if (!mp->m_fsname)
497 return ENOMEM;
498 mp->m_fsname_len = strlen(mp->m_fsname) + 1;
499
500 if (iosizelog) {
501 if (iosizelog > XFS_MAX_IO_LOG ||
502 iosizelog < XFS_MIN_IO_LOG) {
503 cmn_err(CE_WARN,
504 "XFS: invalid log iosize: %d [not %d-%d]",
505 iosizelog, XFS_MIN_IO_LOG,
506 XFS_MAX_IO_LOG);
507 return XFS_ERROR(EINVAL);
508 }
509
510 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
511 mp->m_readio_log = iosizelog;
512 mp->m_writeio_log = iosizelog;
456 } 513 }
457 514
458done:
459 if (args->flags & XFSMNT_32BITINODES)
460 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
461 if (args->flags2)
462 args->flags |= XFSMNT_FLAGS2;
463 return 0; 515 return 0;
464} 516}
465 517
@@ -705,8 +757,7 @@ xfs_close_devices(
705 */ 757 */
706STATIC int 758STATIC int
707xfs_open_devices( 759xfs_open_devices(
708 struct xfs_mount *mp, 760 struct xfs_mount *mp)
709 struct xfs_mount_args *args)
710{ 761{
711 struct block_device *ddev = mp->m_super->s_bdev; 762 struct block_device *ddev = mp->m_super->s_bdev;
712 struct block_device *logdev = NULL, *rtdev = NULL; 763 struct block_device *logdev = NULL, *rtdev = NULL;
@@ -715,14 +766,14 @@ xfs_open_devices(
715 /* 766 /*
716 * Open real time and log devices - order is important. 767 * Open real time and log devices - order is important.
717 */ 768 */
718 if (args->logname[0]) { 769 if (mp->m_logname) {
719 error = xfs_blkdev_get(mp, args->logname, &logdev); 770 error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
720 if (error) 771 if (error)
721 goto out; 772 goto out;
722 } 773 }
723 774
724 if (args->rtname[0]) { 775 if (mp->m_rtname) {
725 error = xfs_blkdev_get(mp, args->rtname, &rtdev); 776 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
726 if (error) 777 if (error)
727 goto out_close_logdev; 778 goto out_close_logdev;
728 779
@@ -1288,175 +1339,28 @@ xfs_fs_setxquota(
1288 1339
1289/* 1340/*
1290 * This function fills in xfs_mount_t fields based on mount args. 1341 * This function fills in xfs_mount_t fields based on mount args.
1291 * Note: the superblock has _not_ yet been read in.
1292 */
1293STATIC int
1294xfs_start_flags(
1295 struct xfs_mount_args *ap,
1296 struct xfs_mount *mp)
1297{
1298 int error;
1299
1300 /* Values are in BBs */
1301 if ((ap->flags & XFSMNT_NOALIGN) != XFSMNT_NOALIGN) {
1302 /*
1303 * At this point the superblock has not been read
1304 * in, therefore we do not know the block size.
1305 * Before the mount call ends we will convert
1306 * these to FSBs.
1307 */
1308 mp->m_dalign = ap->sunit;
1309 mp->m_swidth = ap->swidth;
1310 }
1311
1312 if (ap->logbufs != -1 &&
1313 ap->logbufs != 0 &&
1314 (ap->logbufs < XLOG_MIN_ICLOGS ||
1315 ap->logbufs > XLOG_MAX_ICLOGS)) {
1316 cmn_err(CE_WARN,
1317 "XFS: invalid logbufs value: %d [not %d-%d]",
1318 ap->logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
1319 return XFS_ERROR(EINVAL);
1320 }
1321 mp->m_logbufs = ap->logbufs;
1322 if (ap->logbufsize != -1 &&
1323 ap->logbufsize != 0 &&
1324 (ap->logbufsize < XLOG_MIN_RECORD_BSIZE ||
1325 ap->logbufsize > XLOG_MAX_RECORD_BSIZE ||
1326 !is_power_of_2(ap->logbufsize))) {
1327 cmn_err(CE_WARN,
1328 "XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
1329 ap->logbufsize);
1330 return XFS_ERROR(EINVAL);
1331 }
1332
1333 error = ENOMEM;
1334
1335 mp->m_logbsize = ap->logbufsize;
1336 mp->m_fsname_len = strlen(ap->fsname) + 1;
1337
1338 mp->m_fsname = kstrdup(ap->fsname, GFP_KERNEL);
1339 if (!mp->m_fsname)
1340 goto out;
1341
1342 if (ap->rtname[0]) {
1343 mp->m_rtname = kstrdup(ap->rtname, GFP_KERNEL);
1344 if (!mp->m_rtname)
1345 goto out_free_fsname;
1346
1347 }
1348
1349 if (ap->logname[0]) {
1350 mp->m_logname = kstrdup(ap->logname, GFP_KERNEL);
1351 if (!mp->m_logname)
1352 goto out_free_rtname;
1353 }
1354
1355 if (ap->flags & XFSMNT_WSYNC)
1356 mp->m_flags |= XFS_MOUNT_WSYNC;
1357#if XFS_BIG_INUMS
1358 if (ap->flags & XFSMNT_INO64) {
1359 mp->m_flags |= XFS_MOUNT_INO64;
1360 mp->m_inoadd = XFS_INO64_OFFSET;
1361 }
1362#endif
1363 if (ap->flags & XFSMNT_RETERR)
1364 mp->m_flags |= XFS_MOUNT_RETERR;
1365 if (ap->flags & XFSMNT_NOALIGN)
1366 mp->m_flags |= XFS_MOUNT_NOALIGN;
1367 if (ap->flags & XFSMNT_SWALLOC)
1368 mp->m_flags |= XFS_MOUNT_SWALLOC;
1369 if (ap->flags & XFSMNT_OSYNCISOSYNC)
1370 mp->m_flags |= XFS_MOUNT_OSYNCISOSYNC;
1371 if (ap->flags & XFSMNT_32BITINODES)
1372 mp->m_flags |= XFS_MOUNT_32BITINODES;
1373
1374 if (ap->flags & XFSMNT_IOSIZE) {
1375 if (ap->iosizelog > XFS_MAX_IO_LOG ||
1376 ap->iosizelog < XFS_MIN_IO_LOG) {
1377 cmn_err(CE_WARN,
1378 "XFS: invalid log iosize: %d [not %d-%d]",
1379 ap->iosizelog, XFS_MIN_IO_LOG,
1380 XFS_MAX_IO_LOG);
1381 return XFS_ERROR(EINVAL);
1382 }
1383
1384 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
1385 mp->m_readio_log = mp->m_writeio_log = ap->iosizelog;
1386 }
1387
1388 if (ap->flags & XFSMNT_IKEEP)
1389 mp->m_flags |= XFS_MOUNT_IKEEP;
1390 if (ap->flags & XFSMNT_DIRSYNC)
1391 mp->m_flags |= XFS_MOUNT_DIRSYNC;
1392 if (ap->flags & XFSMNT_ATTR2)
1393 mp->m_flags |= XFS_MOUNT_ATTR2;
1394 if (ap->flags & XFSMNT_NOATTR2)
1395 mp->m_flags |= XFS_MOUNT_NOATTR2;
1396
1397 if (ap->flags2 & XFSMNT2_COMPAT_IOSIZE)
1398 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
1399
1400 /*
1401 * no recovery flag requires a read-only mount
1402 */
1403 if (ap->flags & XFSMNT_NORECOVERY) {
1404 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
1405 cmn_err(CE_WARN,
1406 "XFS: tried to mount a FS read-write without recovery!");
1407 return XFS_ERROR(EINVAL);
1408 }
1409 mp->m_flags |= XFS_MOUNT_NORECOVERY;
1410 }
1411
1412 if (ap->flags & XFSMNT_NOUUID)
1413 mp->m_flags |= XFS_MOUNT_NOUUID;
1414 if (ap->flags & XFSMNT_BARRIER)
1415 mp->m_flags |= XFS_MOUNT_BARRIER;
1416 else
1417 mp->m_flags &= ~XFS_MOUNT_BARRIER;
1418
1419 if (ap->flags2 & XFSMNT2_FILESTREAMS)
1420 mp->m_flags |= XFS_MOUNT_FILESTREAMS;
1421
1422 if (ap->flags & XFSMNT_DMAPI)
1423 mp->m_flags |= XFS_MOUNT_DMAPI;
1424 return 0;
1425
1426
1427 out_free_rtname:
1428 kfree(mp->m_rtname);
1429 out_free_fsname:
1430 kfree(mp->m_fsname);
1431 out:
1432 return error;
1433}
1434
1435/*
1436 * This function fills in xfs_mount_t fields based on mount args.
1437 * Note: the superblock _has_ now been read in. 1342 * Note: the superblock _has_ now been read in.
1438 */ 1343 */
1439STATIC int 1344STATIC int
1440xfs_finish_flags( 1345xfs_finish_flags(
1441 struct xfs_mount_args *ap,
1442 struct xfs_mount *mp) 1346 struct xfs_mount *mp)
1443{ 1347{
1444 int ronly = (mp->m_flags & XFS_MOUNT_RDONLY); 1348 int ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
1445 1349
1446 /* Fail a mount where the logbuf is smaller then the log stripe */ 1350 /* Fail a mount where the logbuf is smaller then the log stripe */
1447 if (xfs_sb_version_haslogv2(&mp->m_sb)) { 1351 if (xfs_sb_version_haslogv2(&mp->m_sb)) {
1448 if ((ap->logbufsize <= 0) && 1352 if (mp->m_logbsize <= 0 &&
1449 (mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE)) { 1353 mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
1450 mp->m_logbsize = mp->m_sb.sb_logsunit; 1354 mp->m_logbsize = mp->m_sb.sb_logsunit;
1451 } else if (ap->logbufsize > 0 && 1355 } else if (mp->m_logbsize > 0 &&
1452 ap->logbufsize < mp->m_sb.sb_logsunit) { 1356 mp->m_logbsize < mp->m_sb.sb_logsunit) {
1453 cmn_err(CE_WARN, 1357 cmn_err(CE_WARN,
1454 "XFS: logbuf size must be greater than or equal to log stripe size"); 1358 "XFS: logbuf size must be greater than or equal to log stripe size");
1455 return XFS_ERROR(EINVAL); 1359 return XFS_ERROR(EINVAL);
1456 } 1360 }
1457 } else { 1361 } else {
1458 /* Fail a mount if the logbuf is larger than 32K */ 1362 /* Fail a mount if the logbuf is larger than 32K */
1459 if (ap->logbufsize > XLOG_BIG_RECORD_BSIZE) { 1363 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
1460 cmn_err(CE_WARN, 1364 cmn_err(CE_WARN,
1461 "XFS: logbuf size for version 1 logs must be 16K or 32K"); 1365 "XFS: logbuf size for version 1 logs must be 16K or 32K");
1462 return XFS_ERROR(EINVAL); 1366 return XFS_ERROR(EINVAL);
@@ -1468,7 +1372,7 @@ xfs_finish_flags(
1468 * told by noattr2 to turn it off 1372 * told by noattr2 to turn it off
1469 */ 1373 */
1470 if (xfs_sb_version_hasattr2(&mp->m_sb) && 1374 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
1471 !(ap->flags & XFSMNT_NOATTR2)) 1375 !(mp->m_flags & XFS_MOUNT_NOATTR2))
1472 mp->m_flags |= XFS_MOUNT_ATTR2; 1376 mp->m_flags |= XFS_MOUNT_ATTR2;
1473 1377
1474 /* 1378 /*
@@ -1480,6 +1384,7 @@ xfs_finish_flags(
1480 return XFS_ERROR(EROFS); 1384 return XFS_ERROR(EROFS);
1481 } 1385 }
1482 1386
1387#if 0 /* shared mounts were never supported on Linux */
1483 /* 1388 /*
1484 * check for shared mount. 1389 * check for shared mount.
1485 */ 1390 */
@@ -1502,25 +1407,11 @@ xfs_finish_flags(
1502 /* 1407 /*
1503 * Shared XFS V0 can't deal with DMI. Return EINVAL. 1408 * Shared XFS V0 can't deal with DMI. Return EINVAL.
1504 */ 1409 */
1505 if (mp->m_sb.sb_shared_vn == 0 && (ap->flags & XFSMNT_DMAPI)) 1410 if (mp->m_sb.sb_shared_vn == 0 &&
1411 (mp->m_flags & XFS_MOUNT_DMAPI))
1506 return XFS_ERROR(EINVAL); 1412 return XFS_ERROR(EINVAL);
1507 } 1413 }
1508 1414#endif
1509 if (ap->flags & XFSMNT_UQUOTA) {
1510 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
1511 if (ap->flags & XFSMNT_UQUOTAENF)
1512 mp->m_qflags |= XFS_UQUOTA_ENFD;
1513 }
1514
1515 if (ap->flags & XFSMNT_GQUOTA) {
1516 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
1517 if (ap->flags & XFSMNT_GQUOTAENF)
1518 mp->m_qflags |= XFS_OQUOTA_ENFD;
1519 } else if (ap->flags & XFSMNT_PQUOTA) {
1520 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
1521 if (ap->flags & XFSMNT_PQUOTAENF)
1522 mp->m_qflags |= XFS_OQUOTA_ENFD;
1523 }
1524 1415
1525 return 0; 1416 return 0;
1526} 1417}
@@ -1533,16 +1424,12 @@ xfs_fs_fill_super(
1533{ 1424{
1534 struct inode *root; 1425 struct inode *root;
1535 struct xfs_mount *mp = NULL; 1426 struct xfs_mount *mp = NULL;
1536 struct xfs_mount_args *args;
1537 int flags = 0, error = ENOMEM; 1427 int flags = 0, error = ENOMEM;
1538 1428 char *mtpt = NULL;
1539 args = xfs_args_allocate(sb, silent);
1540 if (!args)
1541 return -ENOMEM;
1542 1429
1543 mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL); 1430 mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
1544 if (!mp) 1431 if (!mp)
1545 goto out_free_args; 1432 goto out;
1546 1433
1547 spin_lock_init(&mp->m_sb_lock); 1434 spin_lock_init(&mp->m_sb_lock);
1548 mutex_init(&mp->m_growlock); 1435 mutex_init(&mp->m_growlock);
@@ -1554,12 +1441,9 @@ xfs_fs_fill_super(
1554 mp->m_super = sb; 1441 mp->m_super = sb;
1555 sb->s_fs_info = mp; 1442 sb->s_fs_info = mp;
1556 1443
1557 if (sb->s_flags & MS_RDONLY) 1444 error = xfs_parseargs(mp, (char *)data, &mtpt);
1558 mp->m_flags |= XFS_MOUNT_RDONLY;
1559
1560 error = xfs_parseargs(mp, (char *)data, args, 0);
1561 if (error) 1445 if (error)
1562 goto out_free_mp; 1446 goto out_free_fsname;
1563 1447
1564 sb_min_blocksize(sb, BBSIZE); 1448 sb_min_blocksize(sb, BBSIZE);
1565 sb->s_xattr = xfs_xattr_handlers; 1449 sb->s_xattr = xfs_xattr_handlers;
@@ -1567,33 +1451,28 @@ xfs_fs_fill_super(
1567 sb->s_qcop = &xfs_quotactl_operations; 1451 sb->s_qcop = &xfs_quotactl_operations;
1568 sb->s_op = &xfs_super_operations; 1452 sb->s_op = &xfs_super_operations;
1569 1453
1570 error = xfs_dmops_get(mp, args); 1454 error = xfs_dmops_get(mp);
1571 if (error) 1455 if (error)
1572 goto out_free_mp; 1456 goto out_free_fsname;
1573 error = xfs_qmops_get(mp, args); 1457 error = xfs_qmops_get(mp);
1574 if (error) 1458 if (error)
1575 goto out_put_dmops; 1459 goto out_put_dmops;
1576 1460
1577 if (args->flags & XFSMNT_QUIET) 1461 if (silent)
1578 flags |= XFS_MFSI_QUIET; 1462 flags |= XFS_MFSI_QUIET;
1579 1463
1580 error = xfs_open_devices(mp, args); 1464 error = xfs_open_devices(mp);
1581 if (error) 1465 if (error)
1582 goto out_put_qmops; 1466 goto out_put_qmops;
1583 1467
1584 if (xfs_icsb_init_counters(mp)) 1468 if (xfs_icsb_init_counters(mp))
1585 mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB; 1469 mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;
1586 1470
1587 /*
1588 * Setup flags based on mount(2) options and then the superblock
1589 */
1590 error = xfs_start_flags(args, mp);
1591 if (error)
1592 goto out_free_fsname;
1593 error = xfs_readsb(mp, flags); 1471 error = xfs_readsb(mp, flags);
1594 if (error) 1472 if (error)
1595 goto out_free_fsname; 1473 goto out_destroy_counters;
1596 error = xfs_finish_flags(args, mp); 1474
1475 error = xfs_finish_flags(mp);
1597 if (error) 1476 if (error)
1598 goto out_free_sb; 1477 goto out_free_sb;
1599 1478
@@ -1612,7 +1491,7 @@ xfs_fs_fill_super(
1612 if (error) 1491 if (error)
1613 goto out_filestream_unmount; 1492 goto out_filestream_unmount;
1614 1493
1615 XFS_SEND_MOUNT(mp, DM_RIGHT_NULL, args->mtpt, args->fsname); 1494 XFS_SEND_MOUNT(mp, DM_RIGHT_NULL, mtpt, mp->m_fsname);
1616 1495
1617 sb->s_dirt = 1; 1496 sb->s_dirt = 1;
1618 sb->s_magic = XFS_SB_MAGIC; 1497 sb->s_magic = XFS_SB_MAGIC;
@@ -1641,27 +1520,27 @@ xfs_fs_fill_super(
1641 if (error) 1520 if (error)
1642 goto fail_vnrele; 1521 goto fail_vnrele;
1643 1522
1644 xfs_itrace_exit(XFS_I(sb->s_root->d_inode)); 1523 kfree(mtpt);
1645 1524
1646 kfree(args); 1525 xfs_itrace_exit(XFS_I(sb->s_root->d_inode));
1647 return 0; 1526 return 0;
1648 1527
1649 out_filestream_unmount: 1528 out_filestream_unmount:
1650 xfs_filestream_unmount(mp); 1529 xfs_filestream_unmount(mp);
1651 out_free_sb: 1530 out_free_sb:
1652 xfs_freesb(mp); 1531 xfs_freesb(mp);
1653 out_free_fsname: 1532 out_destroy_counters:
1654 xfs_free_fsname(mp);
1655 xfs_icsb_destroy_counters(mp); 1533 xfs_icsb_destroy_counters(mp);
1656 xfs_close_devices(mp); 1534 xfs_close_devices(mp);
1657 out_put_qmops: 1535 out_put_qmops:
1658 xfs_qmops_put(mp); 1536 xfs_qmops_put(mp);
1659 out_put_dmops: 1537 out_put_dmops:
1660 xfs_dmops_put(mp); 1538 xfs_dmops_put(mp);
1661 out_free_mp: 1539 out_free_fsname:
1540 xfs_free_fsname(mp);
1541 kfree(mtpt);
1662 kfree(mp); 1542 kfree(mp);
1663 out_free_args: 1543 out:
1664 kfree(args);
1665 return -error; 1544 return -error;
1666 1545
1667 fail_vnrele: 1546 fail_vnrele:
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index db1986a205a9..5b198d15e76b 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -20,7 +20,6 @@
20#include "xfs_bit.h" 20#include "xfs_bit.h"
21#include "xfs_log.h" 21#include "xfs_log.h"
22#include "xfs_inum.h" 22#include "xfs_inum.h"
23#include "xfs_clnt.h"
24#include "xfs_trans.h" 23#include "xfs_trans.h"
25#include "xfs_sb.h" 24#include "xfs_sb.h"
26#include "xfs_ag.h" 25#include "xfs_ag.h"
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index eea2e60b456b..9556df9f7dab 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -20,7 +20,6 @@
20#include "xfs_bit.h" 20#include "xfs_bit.h"
21#include "xfs_log.h" 21#include "xfs_log.h"
22#include "xfs_inum.h" 22#include "xfs_inum.h"
23#include "xfs_clnt.h"
24#include "xfs_trans.h" 23#include "xfs_trans.h"
25#include "xfs_sb.h" 24#include "xfs_sb.h"
26#include "xfs_ag.h" 25#include "xfs_ag.h"
diff --git a/fs/xfs/xfs_clnt.h b/fs/xfs/xfs_clnt.h
deleted file mode 100644
index d2ce5dd70d87..000000000000
--- a/fs/xfs/xfs_clnt.h
+++ /dev/null
@@ -1,105 +0,0 @@
1/*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * 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 the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18#ifndef __XFS_CLNT_H__
19#define __XFS_CLNT_H__
20
21/*
22 * XFS arguments structure, constructed from the arguments we
23 * are passed via the mount system call.
24 *
25 * NOTE: The mount system call is handled differently between
26 * Linux and IRIX. In IRIX we worked work with a binary data
27 * structure coming in across the syscall interface from user
28 * space (the mount userspace knows about each filesystem type
29 * and the set of valid options for it, and converts the users
30 * argument string into a binary structure _before_ making the
31 * system call), and the ABI issues that this implies.
32 *
33 * In Linux, we are passed a comma separated set of options;
34 * ie. a NULL terminated string of characters. Userspace mount
35 * code does not have any knowledge of mount options expected by
36 * each filesystem type and so each filesystem parses its mount
37 * options in kernel space.
38 *
39 * For the Linux port, we kept this structure pretty much intact
40 * and use it internally (because the existing code groks it).
41 */
42struct xfs_mount_args {
43 int flags; /* flags -> see XFSMNT_... macros below */
44 int flags2; /* flags -> see XFSMNT2_... macros below */
45 int logbufs; /* Number of log buffers, -1 to default */
46 int logbufsize; /* Size of log buffers, -1 to default */
47 char fsname[MAXNAMELEN+1]; /* data device name */
48 char rtname[MAXNAMELEN+1]; /* realtime device filename */
49 char logname[MAXNAMELEN+1]; /* journal device filename */
50 char mtpt[MAXNAMELEN+1]; /* filesystem mount point */
51 int sunit; /* stripe unit (BBs) */
52 int swidth; /* stripe width (BBs), multiple of sunit */
53 uchar_t iosizelog; /* log2 of the preferred I/O size */
54 int ihashsize; /* inode hash table size (buckets) */
55};
56
57/*
58 * XFS mount option flags -- args->flags1
59 */
60#define XFSMNT_ATTR2 0x00000001 /* allow ATTR2 EA format */
61#define XFSMNT_WSYNC 0x00000002 /* safe mode nfs mount
62 * compatible */
63#define XFSMNT_INO64 0x00000004 /* move inode numbers up
64 * past 2^32 */
65#define XFSMNT_UQUOTA 0x00000008 /* user quota accounting */
66#define XFSMNT_PQUOTA 0x00000010 /* IRIX prj quota accounting */
67#define XFSMNT_UQUOTAENF 0x00000020 /* user quota limit
68 * enforcement */
69#define XFSMNT_PQUOTAENF 0x00000040 /* IRIX project quota limit
70 * enforcement */
71#define XFSMNT_QUIET 0x00000080 /* don't report mount errors */
72#define XFSMNT_NOALIGN 0x00000200 /* don't allocate at
73 * stripe boundaries*/
74#define XFSMNT_RETERR 0x00000400 /* return error to user */
75#define XFSMNT_NORECOVERY 0x00000800 /* no recovery, implies
76 * read-only mount */
77#define XFSMNT_SHARED 0x00001000 /* shared XFS mount */
78#define XFSMNT_IOSIZE 0x00002000 /* optimize for I/O size */
79#define XFSMNT_OSYNCISOSYNC 0x00004000 /* o_sync is REALLY o_sync */
80 /* (osyncisdsync is default) */
81#define XFSMNT_NOATTR2 0x00008000 /* turn off ATTR2 EA format */
82#define XFSMNT_32BITINODES 0x00200000 /* restrict inodes to 32
83 * bits of address space */
84#define XFSMNT_GQUOTA 0x00400000 /* group quota accounting */
85#define XFSMNT_GQUOTAENF 0x00800000 /* group quota limit
86 * enforcement */
87#define XFSMNT_NOUUID 0x01000000 /* Ignore fs uuid */
88#define XFSMNT_DMAPI 0x02000000 /* enable dmapi/xdsm */
89#define XFSMNT_BARRIER 0x04000000 /* use write barriers */
90#define XFSMNT_IKEEP 0x08000000 /* inode cluster delete */
91#define XFSMNT_SWALLOC 0x10000000 /* turn on stripe width
92 * allocation */
93#define XFSMNT_DIRSYNC 0x40000000 /* sync creat,link,unlink,rename
94 * symlink,mkdir,rmdir,mknod */
95#define XFSMNT_FLAGS2 0x80000000 /* more flags set in flags2 */
96
97/*
98 * XFS mount option flags -- args->flags2
99 */
100#define XFSMNT2_COMPAT_IOSIZE 0x00000001 /* don't report large preferred
101 * I/O size in stat(2) */
102#define XFSMNT2_FILESTREAMS 0x00000002 /* enable the filestreams
103 * allocator */
104
105#endif /* __XFS_CLNT_H__ */
diff --git a/fs/xfs/xfs_dmops.c b/fs/xfs/xfs_dmops.c
index a1e55fb9d5dd..e71e2581c0c3 100644
--- a/fs/xfs/xfs_dmops.c
+++ b/fs/xfs/xfs_dmops.c
@@ -25,7 +25,6 @@
25#include "xfs_inum.h" 25#include "xfs_inum.h"
26#include "xfs_ag.h" 26#include "xfs_ag.h"
27#include "xfs_mount.h" 27#include "xfs_mount.h"
28#include "xfs_clnt.h"
29 28
30 29
31static struct xfs_dmops xfs_dmcore_stub = { 30static struct xfs_dmops xfs_dmcore_stub = {
@@ -38,9 +37,9 @@ static struct xfs_dmops xfs_dmcore_stub = {
38}; 37};
39 38
40int 39int
41xfs_dmops_get(struct xfs_mount *mp, struct xfs_mount_args *args) 40xfs_dmops_get(struct xfs_mount *mp)
42{ 41{
43 if (args->flags & XFSMNT_DMAPI) { 42 if (mp->m_flags & XFS_MOUNT_DMAPI) {
44 cmn_err(CE_WARN, 43 cmn_err(CE_WARN,
45 "XFS: dmapi support not available in this kernel."); 44 "XFS: dmapi support not available in this kernel.");
46 return EINVAL; 45 return EINVAL;
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index d3b75257602a..e3f618c84e47 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -515,9 +515,9 @@ extern void xfs_freesb(xfs_mount_t *);
515extern int xfs_fs_writable(xfs_mount_t *); 515extern int xfs_fs_writable(xfs_mount_t *);
516extern int xfs_sb_validate_fsb_count(struct xfs_sb *, __uint64_t); 516extern int xfs_sb_validate_fsb_count(struct xfs_sb *, __uint64_t);
517 517
518extern int xfs_dmops_get(struct xfs_mount *, struct xfs_mount_args *); 518extern int xfs_dmops_get(struct xfs_mount *);
519extern void xfs_dmops_put(struct xfs_mount *); 519extern void xfs_dmops_put(struct xfs_mount *);
520extern int xfs_qmops_get(struct xfs_mount *, struct xfs_mount_args *); 520extern int xfs_qmops_get(struct xfs_mount *);
521extern void xfs_qmops_put(struct xfs_mount *); 521extern void xfs_qmops_put(struct xfs_mount *);
522 522
523extern struct xfs_dmops xfs_dmcore_xfs; 523extern struct xfs_dmops xfs_dmcore_xfs;
diff --git a/fs/xfs/xfs_qmops.c b/fs/xfs/xfs_qmops.c
index a294e58db8dd..27f80581520a 100644
--- a/fs/xfs/xfs_qmops.c
+++ b/fs/xfs/xfs_qmops.c
@@ -28,7 +28,6 @@
28#include "xfs_mount.h" 28#include "xfs_mount.h"
29#include "xfs_quota.h" 29#include "xfs_quota.h"
30#include "xfs_error.h" 30#include "xfs_error.h"
31#include "xfs_clnt.h"
32 31
33 32
34STATIC struct xfs_dquot * 33STATIC struct xfs_dquot *
@@ -131,9 +130,9 @@ static struct xfs_qmops xfs_qmcore_stub = {
131}; 130};
132 131
133int 132int
134xfs_qmops_get(struct xfs_mount *mp, struct xfs_mount_args *args) 133xfs_qmops_get(struct xfs_mount *mp)
135{ 134{
136 if (args->flags & (XFSMNT_UQUOTA | XFSMNT_PQUOTA | XFSMNT_GQUOTA)) { 135 if (XFS_IS_QUOTA_RUNNING(mp)) {
137#ifdef CONFIG_XFS_QUOTA 136#ifdef CONFIG_XFS_QUOTA
138 mp->m_qm_ops = &xfs_qmcore_xfs; 137 mp->m_qm_ops = &xfs_qmcore_xfs;
139#else 138#else
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 883dd0f68e9a..305d9f3948e0 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -49,7 +49,6 @@
49#include "xfs_extfree_item.h" 49#include "xfs_extfree_item.h"
50#include "xfs_acl.h" 50#include "xfs_acl.h"
51#include "xfs_attr.h" 51#include "xfs_attr.h"
52#include "xfs_clnt.h"
53#include "xfs_mru_cache.h" 52#include "xfs_mru_cache.h"
54#include "xfs_filestream.h" 53#include "xfs_filestream.h"
55#include "xfs_fsops.h" 54#include "xfs_fsops.h"
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-06 03:50:44 -0500